projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Automatic date update in version.in
[deliverable/binutils-gdb.git] / bfd / elf32-nds32.c
1 /* NDS32-specific support for 32-bit ELF.
2 Copyright (C) 2012-2020 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 "bfdlink.h"
26 #include "libbfd.h"
27 #include "elf-bfd.h"
28 #include "libiberty.h"
29 #include "elf/nds32.h"
30 #include "opcode/nds32.h"
31 #include "elf32-nds32.h"
32 #include "opcode/cgen.h"
33 #include "../opcodes/nds32-opc.h"
34
35 /* All users of this file have bfd_octets_per_byte (abfd, sec) == 1. */
36 #define OCTETS_PER_BYTE(ABFD, SEC) 1
37
38 /* Relocation HOWTO functions. */
39 static bfd_reloc_status_type nds32_elf_ignore_reloc
40 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
41 static bfd_reloc_status_type nds32_elf_9_pcrel_reloc
42 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
43 static bfd_reloc_status_type nds32_elf_hi20_reloc
44 (bfd *, arelent *, asymbol *, void *,
45 asection *, bfd *, char **);
46 static bfd_reloc_status_type nds32_elf_lo12_reloc
47 (bfd *, arelent *, asymbol *, void *,
48 asection *, bfd *, char **);
49 static bfd_reloc_status_type nds32_elf_generic_reloc
50 (bfd *, arelent *, asymbol *, void *,
51 asection *, bfd *, char **);
52 static bfd_reloc_status_type nds32_elf_sda15_reloc
53 (bfd *, arelent *, asymbol *, void *,
54 asection *, bfd *, char **);
55
56 /* Helper functions for HOWTO. */
57 static bfd_reloc_status_type nds32_elf_do_9_pcrel_reloc
58 (bfd *, reloc_howto_type *, asection *, bfd_byte *, bfd_vma,
59 asection *, bfd_vma, bfd_vma);
60
61 /* Nds32 helper functions. */
62 static bfd_vma calculate_memory_address
63 (bfd *, Elf_Internal_Rela *, Elf_Internal_Sym *, Elf_Internal_Shdr *);
64 static int nds32_get_section_contents (bfd *, asection *,
65 bfd_byte **, bfd_boolean);
66 static int nds32_get_local_syms (bfd *, asection *ATTRIBUTE_UNUSED,
67 Elf_Internal_Sym **);
68 static bfd_boolean nds32_relax_fp_as_gp
69 (struct bfd_link_info *link_info, bfd *abfd, asection *sec,
70 Elf_Internal_Rela *internal_relocs, Elf_Internal_Rela *irelend,
71 Elf_Internal_Sym *isymbuf);
72 static bfd_boolean nds32_fag_remove_unused_fpbase
73 (bfd *abfd, asection *sec, Elf_Internal_Rela *internal_relocs,
74 Elf_Internal_Rela *irelend);
75
76 enum
77 {
78 MACH_V1 = bfd_mach_n1h,
79 MACH_V2 = bfd_mach_n1h_v2,
80 MACH_V3 = bfd_mach_n1h_v3,
81 MACH_V3M = bfd_mach_n1h_v3m
82 };
83
84 #define MIN(a, b) ((a) > (b) ? (b) : (a))
85 #define MAX(a, b) ((a) > (b) ? (a) : (b))
86
87 /* The name of the dynamic interpreter. This is put in the .interp
88 section. */
89 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
90
91 #define NDS32_GUARD_SEC_P(flags) ((flags) & SEC_ALLOC \
92 && (flags) & SEC_LOAD \
93 && (flags) & SEC_READONLY)
94
95 /* The nop opcode we use. */
96 #define NDS32_NOP32 0x40000009
97 #define NDS32_NOP16 0x9200
98
99 /* The size in bytes of an entry in the procedure linkage table. */
100 #define PLT_ENTRY_SIZE 24
101 #define PLT_HEADER_SIZE 24
102
103 /* The first entry in a procedure linkage table are reserved,
104 and the initial contents are unimportant (we zero them out).
105 Subsequent entries look like this. */
106 #define PLT0_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(.got+4) */
107 #define PLT0_ENTRY_WORD1 0x58f78000 /* ori r15, r25, LO12(.got+4) */
108 #define PLT0_ENTRY_WORD2 0x05178000 /* lwi r17, [r15+0] */
109 #define PLT0_ENTRY_WORD3 0x04f78001 /* lwi r15, [r15+4] */
110 #define PLT0_ENTRY_WORD4 0x4a003c00 /* jr r15 */
111
112 /* $ta is change to $r15 (from $r25). */
113 #define PLT0_PIC_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(got[1]@GOT) */
114 #define PLT0_PIC_ENTRY_WORD1 0x58f78000 /* ori r15, r15, LO12(got[1]@GOT) */
115 #define PLT0_PIC_ENTRY_WORD2 0x40f7f400 /* add r15, gp, r15 */
116 #define PLT0_PIC_ENTRY_WORD3 0x05178000 /* lwi r17, [r15+0] */
117 #define PLT0_PIC_ENTRY_WORD4 0x04f78001 /* lwi r15, [r15+4] */
118 #define PLT0_PIC_ENTRY_WORD5 0x4a003c00 /* jr r15 */
119
120 #define PLT_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(&got[n+3]) */
121 #define PLT_ENTRY_WORD1 0x04f78000 /* lwi r15, r15, LO12(&got[n+3]) */
122 #define PLT_ENTRY_WORD2 0x4a003c00 /* jr r15 */
123 #define PLT_ENTRY_WORD3 0x45000000 /* movi r16, sizeof(RELA) * n */
124 #define PLT_ENTRY_WORD4 0x48000000 /* j .plt0. */
125
126 #define PLT_PIC_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(got[n+3]@GOT) */
127 #define PLT_PIC_ENTRY_WORD1 0x58f78000 /* ori r15, r15, LO12(got[n+3]@GOT) */
128 #define PLT_PIC_ENTRY_WORD2 0x38febc02 /* lw r15, [gp+r15] */
129 #define PLT_PIC_ENTRY_WORD3 0x4a003c00 /* jr r15 */
130 #define PLT_PIC_ENTRY_WORD4 0x45000000 /* movi r16, sizeof(RELA) * n */
131 #define PLT_PIC_ENTRY_WORD5 0x48000000 /* j .plt0 */
132
133 /* These are macros used to get the relocation accurate value. */
134 #define ACCURATE_8BIT_S1 (0x100)
135 #define ACCURATE_U9BIT_S1 (0x400)
136 #define ACCURATE_12BIT_S1 (0x2000)
137 #define ACCURATE_14BIT_S1 (0x4000)
138 #define ACCURATE_19BIT (0x40000)
139
140 /* These are macros used to get the relocation conservative value. */
141 #define CONSERVATIVE_8BIT_S1 (0x100 - 4)
142 #define CONSERVATIVE_14BIT_S1 (0x4000 - 4)
143 #define CONSERVATIVE_16BIT_S1 (0x10000 - 4)
144 #define CONSERVATIVE_24BIT_S1 (0x1000000 - 4)
145 /* These must be more conservative because the address may be in
146 different segment. */
147 #define CONSERVATIVE_15BIT (0x4000 - 0x1000)
148 #define CONSERVATIVE_15BIT_S1 (0x8000 - 0x1000)
149 #define CONSERVATIVE_15BIT_S2 (0x10000 - 0x1000)
150 #define CONSERVATIVE_19BIT (0x40000 - 0x1000)
151 #define CONSERVATIVE_20BIT (0x80000 - 0x1000)
152
153 /* Size of small data/bss sections, used to calculate SDA_BASE. */
154 static long got_size = 0;
155 static int is_SDA_BASE_set = 0;
156
157 /* Convert ELF-VER in eflags to string for debugging purpose. */
158 static const char *const nds32_elfver_strtab[] =
159 {
160 "ELF-1.2",
161 "ELF-1.3",
162 "ELF-1.4",
163 };
164
165 /* The nds32 linker needs to keep track of the number of relocs that it
166 decides to copy in check_relocs for each symbol. This is so that
167 it can discard PC relative relocs if it doesn't need them when
168 linking with -Bsymbolic. We store the information in a field
169 extending the regular ELF linker hash table. */
170
171 /* This structure keeps track of the number of PC relative relocs we
172 have copied for a given symbol. */
173
174 struct elf_nds32_pcrel_relocs_copied
175 {
176 /* Next section. */
177 struct elf_nds32_pcrel_relocs_copied *next;
178 /* A section in dynobj. */
179 asection *section;
180 /* Number of relocs copied in this section. */
181 bfd_size_type count;
182 };
183
184 enum elf_nds32_tls_type
185 {
186 GOT_UNKNOWN = (0),
187 GOT_NORMAL = (1 << 0),
188 GOT_TLS_LE = (1 << 1),
189 GOT_TLS_IE = (1 << 2),
190 GOT_TLS_IEGP = (1 << 3),
191 GOT_TLS_LD = (1 << 4),
192 GOT_TLS_GD = (1 << 5),
193 GOT_TLS_DESC = (1 << 6),
194 };
195
196 /* Nds32 ELF linker hash entry. */
197
198 struct elf_nds32_link_hash_entry
199 {
200 struct elf_link_hash_entry root;
201
202 /* For checking relocation type. */
203 enum elf_nds32_tls_type tls_type;
204
205 int offset_to_gp;
206 };
207
208 /* Get the nds32 ELF linker hash table from a link_info structure. */
209
210 #define FP_BASE_NAME "_FP_BASE_"
211 static int check_start_export_sym = 0;
212
213 /* The offset for executable tls relaxation. */
214 #define TP_OFFSET 0x0
215
216 typedef struct
217 {
218 int min_id;
219 int max_id;
220 int count;
221 int bias;
222 int init;
223 } elf32_nds32_relax_group_t;
224
225 struct elf_nds32_obj_tdata
226 {
227 struct elf_obj_tdata root;
228
229 /* tls_type for each local got entry. */
230 char *local_got_tls_type;
231
232 /* GOTPLT entries for TLS descriptors. */
233 bfd_vma *local_tlsdesc_gotent;
234
235 /* for R_NDS32_RELAX_GROUP handling. */
236 elf32_nds32_relax_group_t relax_group;
237
238 unsigned int hdr_size;
239 int* offset_to_gp;
240 };
241
242 #define elf_nds32_tdata(bfd) \
243 ((struct elf_nds32_obj_tdata *) (bfd)->tdata.any)
244
245 #define elf32_nds32_local_got_tls_type(bfd) \
246 (elf_nds32_tdata (bfd)->local_got_tls_type)
247
248 #define elf32_nds32_local_gp_offset(bfd) \
249 (elf_nds32_tdata (bfd)->offset_to_gp)
250
251 #define elf32_nds32_hash_entry(ent) ((struct elf_nds32_link_hash_entry *)(ent))
252
253 #define elf32_nds32_relax_group_ptr(bfd) \
254 &(elf_nds32_tdata (bfd)->relax_group)
255
256 static bfd_boolean
257 nds32_elf_mkobject (bfd *abfd)
258 {
259 return bfd_elf_allocate_object (abfd, sizeof (struct elf_nds32_obj_tdata),
260 NDS32_ELF_DATA);
261 }
262
263 /* Relocations used for relocation. */
264 /* Define HOWTO2 (for relocation) and HOWTO3 (for relaxation) to
265 initialize array nds32_elf_howto_table in any order. The benefit
266 is that we can add any new relocations with any numbers and don't
267 need to fill the gap by lots of EMPTY_HOWTO. */
268 #define HOWTO2(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
269 [C] = HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC)
270
271 static reloc_howto_type nds32_elf_howto_table[] =
272 {
273 /* This reloc does nothing. */
274 HOWTO2 (R_NDS32_NONE, /* type */
275 0, /* rightshift */
276 2, /* size (0 = byte, 1 = short, 2 = long) */
277 32, /* bitsize */
278 FALSE, /* pc_relative */
279 0, /* bitpos */
280 complain_overflow_bitfield,/* complain_on_overflow */
281 bfd_elf_generic_reloc, /* special_function */
282 "R_NDS32_NONE", /* name */
283 FALSE, /* partial_inplace */
284 0, /* src_mask */
285 0, /* dst_mask */
286 FALSE), /* pcrel_offset */
287
288 /* A 16 bit absolute relocation. */
289 HOWTO2 (R_NDS32_16, /* type */
290 0, /* rightshift */
291 1, /* size (0 = byte, 1 = short, 2 = long) */
292 16, /* bitsize */
293 FALSE, /* pc_relative */
294 0, /* bitpos */
295 complain_overflow_bitfield,/* complain_on_overflow */
296 nds32_elf_generic_reloc,/* special_function */
297 "R_NDS32_16", /* name */
298 FALSE, /* partial_inplace */
299 0xffff, /* src_mask */
300 0xffff, /* dst_mask */
301 FALSE), /* pcrel_offset */
302
303 /* A 32 bit absolute relocation. */
304 HOWTO2 (R_NDS32_32, /* type */
305 0, /* rightshift */
306 2, /* size (0 = byte, 1 = short, 2 = long) */
307 32, /* bitsize */
308 FALSE, /* pc_relative */
309 0, /* bitpos */
310 complain_overflow_bitfield,/* complain_on_overflow */
311 nds32_elf_generic_reloc,/* special_function */
312 "R_NDS32_32", /* name */
313 FALSE, /* partial_inplace */
314 0xffffffff, /* src_mask */
315 0xffffffff, /* dst_mask */
316 FALSE), /* pcrel_offset */
317
318 /* A 20 bit address. */
319 HOWTO2 (R_NDS32_20, /* type */
320 0, /* rightshift */
321 2, /* size (0 = byte, 1 = short, 2 = long) */
322 20, /* bitsize */
323 FALSE, /* pc_relative */
324 0, /* bitpos */
325 complain_overflow_unsigned,/* complain_on_overflow */
326 nds32_elf_generic_reloc,/* special_function */
327 "R_NDS32_20", /* name */
328 FALSE, /* partial_inplace */
329 0xfffff, /* src_mask */
330 0xfffff, /* dst_mask */
331 FALSE), /* pcrel_offset */
332
333 /* An PC Relative 9-bit relocation, shifted by 2.
334 This reloc is complicated because relocations are relative to pc & -4.
335 i.e. branches in the right insn slot use the address of the left insn
336 slot for pc. */
337 /* It's not clear whether this should have partial_inplace set or not.
338 Branch relaxing in the assembler can store the addend in the insn,
339 and if bfd_install_relocation gets called the addend may get added
340 again. */
341 HOWTO2 (R_NDS32_9_PCREL, /* type */
342 1, /* rightshift */
343 1, /* size (0 = byte, 1 = short, 2 = long) */
344 8, /* bitsize */
345 TRUE, /* pc_relative */
346 0, /* bitpos */
347 complain_overflow_signed,/* complain_on_overflow */
348 nds32_elf_9_pcrel_reloc,/* special_function */
349 "R_NDS32_9_PCREL", /* name */
350 FALSE, /* partial_inplace */
351 0xff, /* src_mask */
352 0xff, /* dst_mask */
353 TRUE), /* pcrel_offset */
354
355 /* A relative 15 bit relocation, right shifted by 1. */
356 HOWTO2 (R_NDS32_15_PCREL, /* type */
357 1, /* rightshift */
358 2, /* size (0 = byte, 1 = short, 2 = long) */
359 14, /* bitsize */
360 TRUE, /* pc_relative */
361 0, /* bitpos */
362 complain_overflow_signed,/* complain_on_overflow */
363 bfd_elf_generic_reloc, /* special_function */
364 "R_NDS32_15_PCREL", /* name */
365 FALSE, /* partial_inplace */
366 0x3fff, /* src_mask */
367 0x3fff, /* dst_mask */
368 TRUE), /* pcrel_offset */
369
370 /* A relative 17 bit relocation, right shifted by 1. */
371 HOWTO2 (R_NDS32_17_PCREL, /* type */
372 1, /* rightshift */
373 2, /* size (0 = byte, 1 = short, 2 = long) */
374 16, /* bitsize */
375 TRUE, /* pc_relative */
376 0, /* bitpos */
377 complain_overflow_signed,/* complain_on_overflow */
378 bfd_elf_generic_reloc, /* special_function */
379 "R_NDS32_17_PCREL", /* name */
380 FALSE, /* partial_inplace */
381 0xffff, /* src_mask */
382 0xffff, /* dst_mask */
383 TRUE), /* pcrel_offset */
384
385 /* A relative 25 bit relocation, right shifted by 1. */
386 /* It's not clear whether this should have partial_inplace set or not.
387 Branch relaxing in the assembler can store the addend in the insn,
388 and if bfd_install_relocation gets called the addend may get added
389 again. */
390 HOWTO2 (R_NDS32_25_PCREL, /* type */
391 1, /* rightshift */
392 2, /* size (0 = byte, 1 = short, 2 = long) */
393 24, /* bitsize */
394 TRUE, /* pc_relative */
395 0, /* bitpos */
396 complain_overflow_signed,/* complain_on_overflow */
397 bfd_elf_generic_reloc, /* special_function */
398 "R_NDS32_25_PCREL", /* name */
399 FALSE, /* partial_inplace */
400 0xffffff, /* src_mask */
401 0xffffff, /* dst_mask */
402 TRUE), /* pcrel_offset */
403
404 /* High 20 bits of address when lower 12 is or'd in. */
405 HOWTO2 (R_NDS32_HI20, /* type */
406 12, /* rightshift */
407 2, /* size (0 = byte, 1 = short, 2 = long) */
408 20, /* bitsize */
409 FALSE, /* pc_relative */
410 0, /* bitpos */
411 complain_overflow_dont,/* complain_on_overflow */
412 nds32_elf_hi20_reloc, /* special_function */
413 "R_NDS32_HI20", /* name */
414 FALSE, /* partial_inplace */
415 0x000fffff, /* src_mask */
416 0x000fffff, /* dst_mask */
417 FALSE), /* pcrel_offset */
418
419 /* Lower 12 bits of address. */
420 HOWTO2 (R_NDS32_LO12S3, /* type */
421 3, /* rightshift */
422 2, /* size (0 = byte, 1 = short, 2 = long) */
423 9, /* bitsize */
424 FALSE, /* pc_relative */
425 0, /* bitpos */
426 complain_overflow_dont,/* complain_on_overflow */
427 nds32_elf_lo12_reloc, /* special_function */
428 "R_NDS32_LO12S3", /* name */
429 FALSE, /* partial_inplace */
430 0x000001ff, /* src_mask */
431 0x000001ff, /* dst_mask */
432 FALSE), /* pcrel_offset */
433
434 /* Lower 12 bits of address. */
435 HOWTO2 (R_NDS32_LO12S2, /* type */
436 2, /* rightshift */
437 2, /* size (0 = byte, 1 = short, 2 = long) */
438 10, /* bitsize */
439 FALSE, /* pc_relative */
440 0, /* bitpos */
441 complain_overflow_dont,/* complain_on_overflow */
442 nds32_elf_lo12_reloc, /* special_function */
443 "R_NDS32_LO12S2", /* name */
444 FALSE, /* partial_inplace */
445 0x000003ff, /* src_mask */
446 0x000003ff, /* dst_mask */
447 FALSE), /* pcrel_offset */
448
449 /* Lower 12 bits of address. */
450 HOWTO2 (R_NDS32_LO12S1, /* type */
451 1, /* rightshift */
452 2, /* size (0 = byte, 1 = short, 2 = long) */
453 11, /* bitsize */
454 FALSE, /* pc_relative */
455 0, /* bitpos */
456 complain_overflow_dont,/* complain_on_overflow */
457 nds32_elf_lo12_reloc, /* special_function */
458 "R_NDS32_LO12S1", /* name */
459 FALSE, /* partial_inplace */
460 0x000007ff, /* src_mask */
461 0x000007ff, /* dst_mask */
462 FALSE), /* pcrel_offset */
463
464 /* Lower 12 bits of address. */
465 HOWTO2 (R_NDS32_LO12S0, /* type */
466 0, /* rightshift */
467 2, /* size (0 = byte, 1 = short, 2 = long) */
468 12, /* bitsize */
469 FALSE, /* pc_relative */
470 0, /* bitpos */
471 complain_overflow_dont,/* complain_on_overflow */
472 nds32_elf_lo12_reloc, /* special_function */
473 "R_NDS32_LO12S0", /* name */
474 FALSE, /* partial_inplace */
475 0x00000fff, /* src_mask */
476 0x00000fff, /* dst_mask */
477 FALSE), /* pcrel_offset */
478
479 /* Small data area 15 bits offset. */
480 HOWTO2 (R_NDS32_SDA15S3, /* type */
481 3, /* rightshift */
482 2, /* size (0 = byte, 1 = short, 2 = long) */
483 15, /* bitsize */
484 FALSE, /* pc_relative */
485 0, /* bitpos */
486 complain_overflow_signed,/* complain_on_overflow */
487 nds32_elf_sda15_reloc, /* special_function */
488 "R_NDS32_SDA15S3", /* name */
489 FALSE, /* partial_inplace */
490 0x00007fff, /* src_mask */
491 0x00007fff, /* dst_mask */
492 FALSE), /* pcrel_offset */
493
494 /* Small data area 15 bits offset. */
495 HOWTO2 (R_NDS32_SDA15S2, /* type */
496 2, /* rightshift */
497 2, /* size (0 = byte, 1 = short, 2 = long) */
498 15, /* bitsize */
499 FALSE, /* pc_relative */
500 0, /* bitpos */
501 complain_overflow_signed,/* complain_on_overflow */
502 nds32_elf_sda15_reloc, /* special_function */
503 "R_NDS32_SDA15S2", /* name */
504 FALSE, /* partial_inplace */
505 0x00007fff, /* src_mask */
506 0x00007fff, /* dst_mask */
507 FALSE), /* pcrel_offset */
508
509 /* Small data area 15 bits offset. */
510 HOWTO2 (R_NDS32_SDA15S1, /* type */
511 1, /* rightshift */
512 2, /* size (0 = byte, 1 = short, 2 = long) */
513 15, /* bitsize */
514 FALSE, /* pc_relative */
515 0, /* bitpos */
516 complain_overflow_signed,/* complain_on_overflow */
517 nds32_elf_sda15_reloc, /* special_function */
518 "R_NDS32_SDA15S1", /* name */
519 FALSE, /* partial_inplace */
520 0x00007fff, /* src_mask */
521 0x00007fff, /* dst_mask */
522 FALSE), /* pcrel_offset */
523
524 /* Small data area 15 bits offset. */
525 HOWTO2 (R_NDS32_SDA15S0, /* type */
526 0, /* rightshift */
527 2, /* size (0 = byte, 1 = short, 2 = long) */
528 15, /* bitsize */
529 FALSE, /* pc_relative */
530 0, /* bitpos */
531 complain_overflow_signed,/* complain_on_overflow */
532 nds32_elf_sda15_reloc, /* special_function */
533 "R_NDS32_SDA15S0", /* name */
534 FALSE, /* partial_inplace */
535 0x00007fff, /* src_mask */
536 0x00007fff, /* dst_mask */
537 FALSE), /* pcrel_offset */
538
539 /* GNU extension to record C++ vtable hierarchy */
540 HOWTO2 (R_NDS32_GNU_VTINHERIT,/* type */
541 0, /* rightshift */
542 2, /* size (0 = byte, 1 = short, 2 = long) */
543 0, /* bitsize */
544 FALSE, /* pc_relative */
545 0, /* bitpos */
546 complain_overflow_dont,/* complain_on_overflow */
547 NULL, /* special_function */
548 "R_NDS32_GNU_VTINHERIT",/* name */
549 FALSE, /* partial_inplace */
550 0, /* src_mask */
551 0, /* dst_mask */
552 FALSE), /* pcrel_offset */
553
554 /* GNU extension to record C++ vtable member usage */
555 HOWTO2 (R_NDS32_GNU_VTENTRY, /* type */
556 0, /* rightshift */
557 2, /* size (0 = byte, 1 = short, 2 = long) */
558 0, /* bitsize */
559 FALSE, /* pc_relative */
560 0, /* bitpos */
561 complain_overflow_dont,/* complain_on_overflow */
562 _bfd_elf_rel_vtable_reloc_fn,/* special_function */
563 "R_NDS32_GNU_VTENTRY", /* name */
564 FALSE, /* partial_inplace */
565 0, /* src_mask */
566 0, /* dst_mask */
567 FALSE), /* pcrel_offset */
568
569 /* A 16 bit absolute relocation. */
570 HOWTO2 (R_NDS32_16_RELA, /* type */
571 0, /* rightshift */
572 1, /* size (0 = byte, 1 = short, 2 = long) */
573 16, /* bitsize */
574 FALSE, /* pc_relative */
575 0, /* bitpos */
576 complain_overflow_bitfield,/* complain_on_overflow */
577 bfd_elf_generic_reloc, /* special_function */
578 "R_NDS32_16_RELA", /* name */
579 FALSE, /* partial_inplace */
580 0xffff, /* src_mask */
581 0xffff, /* dst_mask */
582 FALSE), /* pcrel_offset */
583
584 /* A 32 bit absolute relocation. */
585 HOWTO2 (R_NDS32_32_RELA, /* type */
586 0, /* rightshift */
587 2, /* size (0 = byte, 1 = short, 2 = long) */
588 32, /* bitsize */
589 FALSE, /* pc_relative */
590 0, /* bitpos */
591 complain_overflow_bitfield,/* complain_on_overflow */
592 bfd_elf_generic_reloc, /* special_function */
593 "R_NDS32_32_RELA", /* name */
594 FALSE, /* partial_inplace */
595 0xffffffff, /* src_mask */
596 0xffffffff, /* dst_mask */
597 FALSE), /* pcrel_offset */
598
599 /* A 20 bit address. */
600 HOWTO2 (R_NDS32_20_RELA, /* type */
601 0, /* rightshift */
602 2, /* size (0 = byte, 1 = short, 2 = long) */
603 20, /* bitsize */
604 FALSE, /* pc_relative */
605 0, /* bitpos */
606 complain_overflow_signed,/* complain_on_overflow */
607 bfd_elf_generic_reloc, /* special_function */
608 "R_NDS32_20_RELA", /* name */
609 FALSE, /* partial_inplace */
610 0xfffff, /* src_mask */
611 0xfffff, /* dst_mask */
612 FALSE), /* pcrel_offset */
613
614 HOWTO2 (R_NDS32_9_PCREL_RELA, /* type */
615 1, /* rightshift */
616 1, /* size (0 = byte, 1 = short, 2 = long) */
617 8, /* bitsize */
618 TRUE, /* pc_relative */
619 0, /* bitpos */
620 complain_overflow_signed,/* complain_on_overflow */
621 bfd_elf_generic_reloc, /* special_function */
622 "R_NDS32_9_PCREL_RELA",/* name */
623 FALSE, /* partial_inplace */
624 0xff, /* src_mask */
625 0xff, /* dst_mask */
626 TRUE), /* pcrel_offset */
627
628 /* A relative 15 bit relocation, right shifted by 1. */
629 HOWTO2 (R_NDS32_15_PCREL_RELA,/* type */
630 1, /* rightshift */
631 2, /* size (0 = byte, 1 = short, 2 = long) */
632 14, /* bitsize */
633 TRUE, /* pc_relative */
634 0, /* bitpos */
635 complain_overflow_signed,/* complain_on_overflow */
636 bfd_elf_generic_reloc, /* special_function */
637 "R_NDS32_15_PCREL_RELA",/* name */
638 FALSE, /* partial_inplace */
639 0x3fff, /* src_mask */
640 0x3fff, /* dst_mask */
641 TRUE), /* pcrel_offset */
642
643 /* A relative 17 bit relocation, right shifted by 1. */
644 HOWTO2 (R_NDS32_17_PCREL_RELA,/* type */
645 1, /* rightshift */
646 2, /* size (0 = byte, 1 = short, 2 = long) */
647 16, /* bitsize */
648 TRUE, /* pc_relative */
649 0, /* bitpos */
650 complain_overflow_signed,/* complain_on_overflow */
651 bfd_elf_generic_reloc, /* special_function */
652 "R_NDS32_17_PCREL_RELA",/* name */
653 FALSE, /* partial_inplace */
654 0xffff, /* src_mask */
655 0xffff, /* dst_mask */
656 TRUE), /* pcrel_offset */
657
658 /* A relative 25 bit relocation, right shifted by 2. */
659 HOWTO2 (R_NDS32_25_PCREL_RELA,/* type */
660 1, /* rightshift */
661 2, /* size (0 = byte, 1 = short, 2 = long) */
662 24, /* bitsize */
663 TRUE, /* pc_relative */
664 0, /* bitpos */
665 complain_overflow_signed,/* complain_on_overflow */
666 bfd_elf_generic_reloc, /* special_function */
667 "R_NDS32_25_PCREL_RELA",/* name */
668 FALSE, /* partial_inplace */
669 0xffffff, /* src_mask */
670 0xffffff, /* dst_mask */
671 TRUE), /* pcrel_offset */
672
673 /* High 20 bits of address when lower 16 is or'd in. */
674 HOWTO2 (R_NDS32_HI20_RELA, /* type */
675 12, /* rightshift */
676 2, /* size (0 = byte, 1 = short, 2 = long) */
677 20, /* bitsize */
678 FALSE, /* pc_relative */
679 0, /* bitpos */
680 complain_overflow_dont,/* complain_on_overflow */
681 bfd_elf_generic_reloc, /* special_function */
682 "R_NDS32_HI20_RELA", /* name */
683 FALSE, /* partial_inplace */
684 0x000fffff, /* src_mask */
685 0x000fffff, /* dst_mask */
686 FALSE), /* pcrel_offset */
687
688 /* Lower 12 bits of address. */
689 HOWTO2 (R_NDS32_LO12S3_RELA, /* type */
690 3, /* rightshift */
691 2, /* size (0 = byte, 1 = short, 2 = long) */
692 9, /* bitsize */
693 FALSE, /* pc_relative */
694 0, /* bitpos */
695 complain_overflow_dont,/* complain_on_overflow */
696 bfd_elf_generic_reloc, /* special_function */
697 "R_NDS32_LO12S3_RELA", /* name */
698 FALSE, /* partial_inplace */
699 0x000001ff, /* src_mask */
700 0x000001ff, /* dst_mask */
701 FALSE), /* pcrel_offset */
702
703 /* Lower 12 bits of address. */
704 HOWTO2 (R_NDS32_LO12S2_RELA, /* type */
705 2, /* rightshift */
706 2, /* size (0 = byte, 1 = short, 2 = long) */
707 10, /* bitsize */
708 FALSE, /* pc_relative */
709 0, /* bitpos */
710 complain_overflow_dont,/* complain_on_overflow */
711 bfd_elf_generic_reloc, /* special_function */
712 "R_NDS32_LO12S2_RELA", /* name */
713 FALSE, /* partial_inplace */
714 0x000003ff, /* src_mask */
715 0x000003ff, /* dst_mask */
716 FALSE), /* pcrel_offset */
717
718 /* Lower 12 bits of address. */
719 HOWTO2 (R_NDS32_LO12S1_RELA, /* type */
720 1, /* rightshift */
721 2, /* size (0 = byte, 1 = short, 2 = long) */
722 11, /* bitsize */
723 FALSE, /* pc_relative */
724 0, /* bitpos */
725 complain_overflow_dont,/* complain_on_overflow */
726 bfd_elf_generic_reloc, /* special_function */
727 "R_NDS32_LO12S1_RELA", /* name */
728 FALSE, /* partial_inplace */
729 0x000007ff, /* src_mask */
730 0x000007ff, /* dst_mask */
731 FALSE), /* pcrel_offset */
732
733 /* Lower 12 bits of address. */
734 HOWTO2 (R_NDS32_LO12S0_RELA, /* type */
735 0, /* rightshift */
736 2, /* size (0 = byte, 1 = short, 2 = long) */
737 12, /* bitsize */
738 FALSE, /* pc_relative */
739 0, /* bitpos */
740 complain_overflow_dont,/* complain_on_overflow */
741 bfd_elf_generic_reloc, /* special_function */
742 "R_NDS32_LO12S0_RELA", /* name */
743 FALSE, /* partial_inplace */
744 0x00000fff, /* src_mask */
745 0x00000fff, /* dst_mask */
746 FALSE), /* pcrel_offset */
747
748 /* Small data area 15 bits offset. */
749 HOWTO2 (R_NDS32_SDA15S3_RELA, /* type */
750 3, /* rightshift */
751 2, /* size (0 = byte, 1 = short, 2 = long) */
752 15, /* bitsize */
753 FALSE, /* pc_relative */
754 0, /* bitpos */
755 complain_overflow_signed,/* complain_on_overflow */
756 bfd_elf_generic_reloc, /* special_function */
757 "R_NDS32_SDA15S3_RELA",/* name */
758 FALSE, /* partial_inplace */
759 0x00007fff, /* src_mask */
760 0x00007fff, /* dst_mask */
761 FALSE), /* pcrel_offset */
762
763 /* Small data area 15 bits offset. */
764 HOWTO2 (R_NDS32_SDA15S2_RELA, /* type */
765 2, /* rightshift */
766 2, /* size (0 = byte, 1 = short, 2 = long) */
767 15, /* bitsize */
768 FALSE, /* pc_relative */
769 0, /* bitpos */
770 complain_overflow_signed,/* complain_on_overflow */
771 bfd_elf_generic_reloc, /* special_function */
772 "R_NDS32_SDA15S2_RELA",/* name */
773 FALSE, /* partial_inplace */
774 0x00007fff, /* src_mask */
775 0x00007fff, /* dst_mask */
776 FALSE), /* pcrel_offset */
777
778 HOWTO2 (R_NDS32_SDA15S1_RELA, /* type */
779 1, /* rightshift */
780 2, /* size (0 = byte, 1 = short, 2 = long) */
781 15, /* bitsize */
782 FALSE, /* pc_relative */
783 0, /* bitpos */
784 complain_overflow_signed,/* complain_on_overflow */
785 bfd_elf_generic_reloc, /* special_function */
786 "R_NDS32_SDA15S1_RELA",/* name */
787 FALSE, /* partial_inplace */
788 0x00007fff, /* src_mask */
789 0x00007fff, /* dst_mask */
790 FALSE), /* pcrel_offset */
791
792 HOWTO2 (R_NDS32_SDA15S0_RELA, /* type */
793 0, /* rightshift */
794 2, /* size (0 = byte, 1 = short, 2 = long) */
795 15, /* bitsize */
796 FALSE, /* pc_relative */
797 0, /* bitpos */
798 complain_overflow_signed,/* complain_on_overflow */
799 bfd_elf_generic_reloc, /* special_function */
800 "R_NDS32_SDA15S0_RELA",/* name */
801 FALSE, /* partial_inplace */
802 0x00007fff, /* src_mask */
803 0x00007fff, /* dst_mask */
804 FALSE), /* pcrel_offset */
805
806 /* GNU extension to record C++ vtable hierarchy */
807 HOWTO2 (R_NDS32_RELA_GNU_VTINHERIT,/* type */
808 0, /* rightshift */
809 2, /* size (0 = byte, 1 = short, 2 = long) */
810 0, /* bitsize */
811 FALSE, /* pc_relative */
812 0, /* bitpos */
813 complain_overflow_dont,/* complain_on_overflow */
814 NULL, /* special_function */
815 "R_NDS32_RELA_GNU_VTINHERIT",/* name */
816 FALSE, /* partial_inplace */
817 0, /* src_mask */
818 0, /* dst_mask */
819 FALSE), /* pcrel_offset */
820
821 /* GNU extension to record C++ vtable member usage */
822 HOWTO2 (R_NDS32_RELA_GNU_VTENTRY,/* type */
823 0, /* rightshift */
824 2, /* size (0 = byte, 1 = short, 2 = long) */
825 0, /* bitsize */
826 FALSE, /* pc_relative */
827 0, /* bitpos */
828 complain_overflow_dont,/* complain_on_overflow */
829 _bfd_elf_rel_vtable_reloc_fn,/* special_function */
830 "R_NDS32_RELA_GNU_VTENTRY",/* name */
831 FALSE, /* partial_inplace */
832 0, /* src_mask */
833 0, /* dst_mask */
834 FALSE), /* pcrel_offset */
835
836 /* Like R_NDS32_20, but referring to the GOT table entry for
837 the symbol. */
838 HOWTO2 (R_NDS32_GOT20, /* type */
839 0, /* rightshift */
840 2, /* size (0 = byte, 1 = short, 2 = long) */
841 20, /* bitsize */
842 FALSE, /* pc_relative */
843 0, /* bitpos */
844 complain_overflow_signed,/* complain_on_overflow */
845 bfd_elf_generic_reloc, /* special_function */
846 "R_NDS32_GOT20", /* name */
847 FALSE, /* partial_inplace */
848 0xfffff, /* src_mask */
849 0xfffff, /* dst_mask */
850 FALSE), /* pcrel_offset */
851
852 /* Like R_NDS32_PCREL, but referring to the procedure linkage table
853 entry for the symbol. */
854 HOWTO2 (R_NDS32_25_PLTREL, /* type */
855 1, /* rightshift */
856 2, /* size (0 = byte, 1 = short, 2 = long) */
857 24, /* bitsize */
858 TRUE, /* pc_relative */
859 0, /* bitpos */
860 complain_overflow_signed,/* complain_on_overflow */
861 bfd_elf_generic_reloc, /* special_function */
862 "R_NDS32_25_PLTREL", /* name */
863 FALSE, /* partial_inplace */
864 0xffffff, /* src_mask */
865 0xffffff, /* dst_mask */
866 TRUE), /* pcrel_offset */
867
868 /* This is used only by the dynamic linker. The symbol should exist
869 both in the object being run and in some shared library. The
870 dynamic linker copies the data addressed by the symbol from the
871 shared library into the object, because the object being
872 run has to have the data at some particular address. */
873 HOWTO2 (R_NDS32_COPY, /* type */
874 0, /* rightshift */
875 2, /* size (0 = byte, 1 = short, 2 = long) */
876 32, /* bitsize */
877 FALSE, /* pc_relative */
878 0, /* bitpos */
879 complain_overflow_bitfield,/* complain_on_overflow */
880 bfd_elf_generic_reloc, /* special_function */
881 "R_NDS32_COPY", /* name */
882 FALSE, /* partial_inplace */
883 0xffffffff, /* src_mask */
884 0xffffffff, /* dst_mask */
885 FALSE), /* pcrel_offset */
886
887 /* Like R_NDS32_20, but used when setting global offset table
888 entries. */
889 HOWTO2 (R_NDS32_GLOB_DAT, /* type */
890 0, /* rightshift */
891 2, /* size (0 = byte, 1 = short, 2 = long) */
892 32, /* bitsize */
893 FALSE, /* pc_relative */
894 0, /* bitpos */
895 complain_overflow_bitfield,/* complain_on_overflow */
896 bfd_elf_generic_reloc, /* special_function */
897 "R_NDS32_GLOB_DAT", /* name */
898 FALSE, /* partial_inplace */
899 0xffffffff, /* src_mask */
900 0xffffffff, /* dst_mask */
901 FALSE), /* pcrel_offset */
902
903 /* Marks a procedure linkage table entry for a symbol. */
904 HOWTO2 (R_NDS32_JMP_SLOT, /* type */
905 0, /* rightshift */
906 2, /* size (0 = byte, 1 = short, 2 = long) */
907 32, /* bitsize */
908 FALSE, /* pc_relative */
909 0, /* bitpos */
910 complain_overflow_bitfield,/* complain_on_overflow */
911 bfd_elf_generic_reloc, /* special_function */
912 "R_NDS32_JMP_SLOT", /* name */
913 FALSE, /* partial_inplace */
914 0xffffffff, /* src_mask */
915 0xffffffff, /* dst_mask */
916 FALSE), /* pcrel_offset */
917
918 /* Used only by the dynamic linker. When the object is run, this
919 longword is set to the load address of the object, plus the
920 addend. */
921 HOWTO2 (R_NDS32_RELATIVE, /* type */
922 0, /* rightshift */
923 2, /* size (0 = byte, 1 = short, 2 = long) */
924 32, /* bitsize */
925 FALSE, /* pc_relative */
926 0, /* bitpos */
927 complain_overflow_bitfield,/* complain_on_overflow */
928 bfd_elf_generic_reloc, /* special_function */
929 "R_NDS32_RELATIVE", /* name */
930 FALSE, /* partial_inplace */
931 0xffffffff, /* src_mask */
932 0xffffffff, /* dst_mask */
933 FALSE), /* pcrel_offset */
934
935 HOWTO2 (R_NDS32_GOTOFF, /* type */
936 0, /* rightshift */
937 2, /* size (0 = byte, 1 = short, 2 = long) */
938 20, /* bitsize */
939 FALSE, /* pc_relative */
940 0, /* bitpos */
941 complain_overflow_signed,/* complain_on_overflow */
942 bfd_elf_generic_reloc, /* special_function */
943 "R_NDS32_GOTOFF", /* name */
944 FALSE, /* partial_inplace */
945 0xfffff, /* src_mask */
946 0xfffff, /* dst_mask */
947 FALSE), /* pcrel_offset */
948
949 /* An PC Relative 20-bit relocation used when setting PIC offset
950 table register. */
951 HOWTO2 (R_NDS32_GOTPC20, /* type */
952 0, /* rightshift */
953 2, /* size (0 = byte, 1 = short, 2 = long) */
954 20, /* bitsize */
955 TRUE, /* pc_relative */
956 0, /* bitpos */
957 complain_overflow_signed,/* complain_on_overflow */
958 bfd_elf_generic_reloc, /* special_function */
959 "R_NDS32_GOTPC20", /* name */
960 FALSE, /* partial_inplace */
961 0xfffff, /* src_mask */
962 0xfffff, /* dst_mask */
963 TRUE), /* pcrel_offset */
964
965 /* Like R_NDS32_HI20, but referring to the GOT table entry for
966 the symbol. */
967 HOWTO2 (R_NDS32_GOT_HI20, /* type */
968 12, /* rightshift */
969 2, /* size (0 = byte, 1 = short, 2 = long) */
970 20, /* bitsize */
971 FALSE, /* pc_relative */
972 0, /* bitpos */
973 complain_overflow_dont,/* complain_on_overflow */
974 bfd_elf_generic_reloc, /* special_function */
975 "R_NDS32_GOT_HI20", /* name */
976 FALSE, /* partial_inplace */
977 0x000fffff, /* src_mask */
978 0x000fffff, /* dst_mask */
979 FALSE), /* pcrel_offset */
980 HOWTO2 (R_NDS32_GOT_LO12, /* type */
981 0, /* rightshift */
982 2, /* size (0 = byte, 1 = short, 2 = long) */
983 12, /* bitsize */
984 FALSE, /* pc_relative */
985 0, /* bitpos */
986 complain_overflow_dont,/* complain_on_overflow */
987 bfd_elf_generic_reloc, /* special_function */
988 "R_NDS32_GOT_LO12", /* name */
989 FALSE, /* partial_inplace */
990 0x00000fff, /* src_mask */
991 0x00000fff, /* dst_mask */
992 FALSE), /* pcrel_offset */
993
994 /* An PC Relative relocation used when setting PIC offset table register.
995 Like R_NDS32_HI20, but referring to the GOT table entry for
996 the symbol. */
997 HOWTO2 (R_NDS32_GOTPC_HI20, /* type */
998 12, /* rightshift */
999 2, /* size (0 = byte, 1 = short, 2 = long) */
1000 20, /* bitsize */
1001 FALSE, /* pc_relative */
1002 0, /* bitpos */
1003 complain_overflow_dont,/* complain_on_overflow */
1004 bfd_elf_generic_reloc, /* special_function */
1005 "R_NDS32_GOTPC_HI20", /* name */
1006 FALSE, /* partial_inplace */
1007 0x000fffff, /* src_mask */
1008 0x000fffff, /* dst_mask */
1009 TRUE), /* pcrel_offset */
1010 HOWTO2 (R_NDS32_GOTPC_LO12, /* type */
1011 0, /* rightshift */
1012 2, /* size (0 = byte, 1 = short, 2 = long) */
1013 12, /* bitsize */
1014 FALSE, /* pc_relative */
1015 0, /* bitpos */
1016 complain_overflow_dont,/* complain_on_overflow */
1017 bfd_elf_generic_reloc, /* special_function */
1018 "R_NDS32_GOTPC_LO12", /* name */
1019 FALSE, /* partial_inplace */
1020 0x00000fff, /* src_mask */
1021 0x00000fff, /* dst_mask */
1022 TRUE), /* pcrel_offset */
1023
1024 HOWTO2 (R_NDS32_GOTOFF_HI20, /* type */
1025 12, /* rightshift */
1026 2, /* size (0 = byte, 1 = short, 2 = long) */
1027 20, /* bitsize */
1028 FALSE, /* pc_relative */
1029 0, /* bitpos */
1030 complain_overflow_dont,/* complain_on_overflow */
1031 bfd_elf_generic_reloc, /* special_function */
1032 "R_NDS32_GOTOFF_HI20", /* name */
1033 FALSE, /* partial_inplace */
1034 0x000fffff, /* src_mask */
1035 0x000fffff, /* dst_mask */
1036 FALSE), /* pcrel_offset */
1037 HOWTO2 (R_NDS32_GOTOFF_LO12, /* type */
1038 0, /* rightshift */
1039 2, /* size (0 = byte, 1 = short, 2 = long) */
1040 12, /* bitsize */
1041 FALSE, /* pc_relative */
1042 0, /* bitpos */
1043 complain_overflow_dont,/* complain_on_overflow */
1044 bfd_elf_generic_reloc, /* special_function */
1045 "R_NDS32_GOTOFF_LO12", /* name */
1046 FALSE, /* partial_inplace */
1047 0x00000fff, /* src_mask */
1048 0x00000fff, /* dst_mask */
1049 FALSE), /* pcrel_offset */
1050
1051 /* Alignment hint for relaxable instruction. This is used with
1052 R_NDS32_LABEL as a pair. Relax this instruction from 4 bytes to 2
1053 in order to make next label aligned on word boundary. */
1054 HOWTO2 (R_NDS32_INSN16, /* type */
1055 0, /* rightshift */
1056 2, /* size (0 = byte, 1 = short, 2 = long) */
1057 32, /* bitsize */
1058 FALSE, /* pc_relative */
1059 0, /* bitpos */
1060 complain_overflow_dont,/* complain_on_overflow */
1061 nds32_elf_ignore_reloc,/* special_function */
1062 "R_NDS32_INSN16", /* name */
1063 FALSE, /* partial_inplace */
1064 0x00000fff, /* src_mask */
1065 0x00000fff, /* dst_mask */
1066 FALSE), /* pcrel_offset */
1067
1068 /* Alignment hint for label. */
1069 HOWTO2 (R_NDS32_LABEL, /* type */
1070 0, /* rightshift */
1071 2, /* size (0 = byte, 1 = short, 2 = long) */
1072 32, /* bitsize */
1073 FALSE, /* pc_relative */
1074 0, /* bitpos */
1075 complain_overflow_dont,/* complain_on_overflow */
1076 nds32_elf_ignore_reloc,/* special_function */
1077 "R_NDS32_LABEL", /* name */
1078 FALSE, /* partial_inplace */
1079 0xffffffff, /* src_mask */
1080 0xffffffff, /* dst_mask */
1081 FALSE), /* pcrel_offset */
1082
1083 /* Relax hint for unconditional call sequence */
1084 HOWTO2 (R_NDS32_LONGCALL1, /* type */
1085 0, /* rightshift */
1086 2, /* size (0 = byte, 1 = short, 2 = long) */
1087 32, /* bitsize */
1088 FALSE, /* pc_relative */
1089 0, /* bitpos */
1090 complain_overflow_dont,/* complain_on_overflow */
1091 nds32_elf_ignore_reloc,/* special_function */
1092 "R_NDS32_LONGCALL1", /* name */
1093 FALSE, /* partial_inplace */
1094 0xffffffff, /* src_mask */
1095 0xffffffff, /* dst_mask */
1096 FALSE), /* pcrel_offset */
1097
1098 /* Relax hint for conditional call sequence. */
1099 HOWTO2 (R_NDS32_LONGCALL2, /* type */
1100 0, /* rightshift */
1101 2, /* size (0 = byte, 1 = short, 2 = long) */
1102 32, /* bitsize */
1103 FALSE, /* pc_relative */
1104 0, /* bitpos */
1105 complain_overflow_dont,/* complain_on_overflow */
1106 nds32_elf_ignore_reloc,/* special_function */
1107 "R_NDS32_LONGCALL2", /* name */
1108 FALSE, /* partial_inplace */
1109 0xffffffff, /* src_mask */
1110 0xffffffff, /* dst_mask */
1111 FALSE), /* pcrel_offset */
1112
1113 /* Relax hint for conditional call sequence. */
1114 HOWTO2 (R_NDS32_LONGCALL3, /* type */
1115 0, /* rightshift */
1116 2, /* size (0 = byte, 1 = short, 2 = long) */
1117 32, /* bitsize */
1118 FALSE, /* pc_relative */
1119 0, /* bitpos */
1120 complain_overflow_dont,/* complain_on_overflow */
1121 nds32_elf_ignore_reloc,/* special_function */
1122 "R_NDS32_LONGCALL3", /* name */
1123 FALSE, /* partial_inplace */
1124 0xffffffff, /* src_mask */
1125 0xffffffff, /* dst_mask */
1126 FALSE), /* pcrel_offset */
1127
1128 /* Relax hint for unconditional branch sequence. */
1129 HOWTO2 (R_NDS32_LONGJUMP1, /* type */
1130 0, /* rightshift */
1131 2, /* size (0 = byte, 1 = short, 2 = long) */
1132 32, /* bitsize */
1133 FALSE, /* pc_relative */
1134 0, /* bitpos */
1135 complain_overflow_dont,/* complain_on_overflow */
1136 nds32_elf_ignore_reloc,/* special_function */
1137 "R_NDS32_LONGJUMP1", /* name */
1138 FALSE, /* partial_inplace */
1139 0xffffffff, /* src_mask */
1140 0xffffffff, /* dst_mask */
1141 FALSE), /* pcrel_offset */
1142
1143 /* Relax hint for conditional branch sequence. */
1144 HOWTO2 (R_NDS32_LONGJUMP2, /* type */
1145 0, /* rightshift */
1146 2, /* size (0 = byte, 1 = short, 2 = long) */
1147 32, /* bitsize */
1148 FALSE, /* pc_relative */
1149 0, /* bitpos */
1150 complain_overflow_dont,/* complain_on_overflow */
1151 nds32_elf_ignore_reloc,/* special_function */
1152 "R_NDS32_LONGJUMP2", /* name */
1153 FALSE, /* partial_inplace */
1154 0xffffffff, /* src_mask */
1155 0xffffffff, /* dst_mask */
1156 FALSE), /* pcrel_offset */
1157
1158 /* Relax hint for conditional branch sequence. */
1159 HOWTO2 (R_NDS32_LONGJUMP3, /* type */
1160 0, /* rightshift */
1161 2, /* size (0 = byte, 1 = short, 2 = long) */
1162 32, /* bitsize */
1163 FALSE, /* pc_relative */
1164 0, /* bitpos */
1165 complain_overflow_dont,/* complain_on_overflow */
1166 nds32_elf_ignore_reloc,/* special_function */
1167 "R_NDS32_LONGJUMP3", /* name */
1168 FALSE, /* partial_inplace */
1169 0xffffffff, /* src_mask */
1170 0xffffffff, /* dst_mask */
1171 FALSE), /* pcrel_offset */
1172
1173 /* Relax hint for load/store sequence. */
1174 HOWTO2 (R_NDS32_LOADSTORE, /* type */
1175 0, /* rightshift */
1176 2, /* size (0 = byte, 1 = short, 2 = long) */
1177 32, /* bitsize */
1178 FALSE, /* pc_relative */
1179 0, /* bitpos */
1180 complain_overflow_dont,/* complain_on_overflow */
1181 nds32_elf_ignore_reloc,/* special_function */
1182 "R_NDS32_LOADSTORE", /* name */
1183 FALSE, /* partial_inplace */
1184 0xffffffff, /* src_mask */
1185 0xffffffff, /* dst_mask */
1186 FALSE), /* pcrel_offset */
1187
1188 /* Relax hint for load/store sequence. */
1189 HOWTO2 (R_NDS32_9_FIXED_RELA, /* type */
1190 0, /* rightshift */
1191 1, /* size (0 = byte, 1 = short, 2 = long) */
1192 16, /* bitsize */
1193 FALSE, /* pc_relative */
1194 0, /* bitpos */
1195 complain_overflow_dont,/* complain_on_overflow */
1196 nds32_elf_ignore_reloc,/* special_function */
1197 "R_NDS32_9_FIXED_RELA",/* name */
1198 FALSE, /* partial_inplace */
1199 0x000000ff, /* src_mask */
1200 0x000000ff, /* dst_mask */
1201 FALSE), /* pcrel_offset */
1202
1203 /* Relax hint for load/store sequence. */
1204 HOWTO2 (R_NDS32_15_FIXED_RELA,/* type */
1205 0, /* rightshift */
1206 2, /* size (0 = byte, 1 = short, 2 = long) */
1207 32, /* bitsize */
1208 FALSE, /* pc_relative */
1209 0, /* bitpos */
1210 complain_overflow_dont,/* complain_on_overflow */
1211 nds32_elf_ignore_reloc,/* special_function */
1212 "R_NDS32_15_FIXED_RELA",/* name */
1213 FALSE, /* partial_inplace */
1214 0x00003fff, /* src_mask */
1215 0x00003fff, /* dst_mask */
1216 FALSE), /* pcrel_offset */
1217
1218 /* Relax hint for load/store sequence. */
1219 HOWTO2 (R_NDS32_17_FIXED_RELA,/* type */
1220 0, /* rightshift */
1221 2, /* size (0 = byte, 1 = short, 2 = long) */
1222 32, /* bitsize */
1223 FALSE, /* pc_relative */
1224 0, /* bitpos */
1225 complain_overflow_dont,/* complain_on_overflow */
1226 nds32_elf_ignore_reloc,/* special_function */
1227 "R_NDS32_17_FIXED_RELA",/* name */
1228 FALSE, /* partial_inplace */
1229 0x0000ffff, /* src_mask */
1230 0x0000ffff, /* dst_mask */
1231 FALSE), /* pcrel_offset */
1232
1233 /* Relax hint for load/store sequence. */
1234 HOWTO2 (R_NDS32_25_FIXED_RELA,/* type */
1235 0, /* rightshift */
1236 2, /* size (0 = byte, 1 = short, 2 = long) */
1237 32, /* bitsize */
1238 FALSE, /* pc_relative */
1239 0, /* bitpos */
1240 complain_overflow_dont,/* complain_on_overflow */
1241 nds32_elf_ignore_reloc,/* special_function */
1242 "R_NDS32_25_FIXED_RELA",/* name */
1243 FALSE, /* partial_inplace */
1244 0x00ffffff, /* src_mask */
1245 0x00ffffff, /* dst_mask */
1246 FALSE), /* pcrel_offset */
1247
1248 /* High 20 bits of PLT symbol offset relative to PC. */
1249 HOWTO2 (R_NDS32_PLTREL_HI20, /* type */
1250 12, /* rightshift */
1251 2, /* size (0 = byte, 1 = short, 2 = long) */
1252 20, /* bitsize */
1253 FALSE, /* pc_relative */
1254 0, /* bitpos */
1255 complain_overflow_dont,/* complain_on_overflow */
1256 bfd_elf_generic_reloc, /* special_function */
1257 "R_NDS32_PLTREL_HI20", /* name */
1258 FALSE, /* partial_inplace */
1259 0x000fffff, /* src_mask */
1260 0x000fffff, /* dst_mask */
1261 FALSE), /* pcrel_offset */
1262
1263 /* Low 12 bits of PLT symbol offset relative to PC. */
1264 HOWTO2 (R_NDS32_PLTREL_LO12, /* type */
1265 0, /* rightshift */
1266 2, /* size (0 = byte, 1 = short, 2 = long) */
1267 12, /* bitsize */
1268 FALSE, /* pc_relative */
1269 0, /* bitpos */
1270 complain_overflow_dont,/* complain_on_overflow */
1271 bfd_elf_generic_reloc, /* special_function */
1272 "R_NDS32_PLTREL_LO12", /* name */
1273 FALSE, /* partial_inplace */
1274 0x00000fff, /* src_mask */
1275 0x00000fff, /* dst_mask */
1276 FALSE), /* pcrel_offset */
1277
1278 /* High 20 bits of PLT symbol offset relative to GOT (GP). */
1279 HOWTO2 (R_NDS32_PLT_GOTREL_HI20, /* type */
1280 12, /* rightshift */
1281 2, /* size (0 = byte, 1 = short, 2 = long) */
1282 20, /* bitsize */
1283 FALSE, /* pc_relative */
1284 0, /* bitpos */
1285 complain_overflow_dont,/* complain_on_overflow */
1286 bfd_elf_generic_reloc, /* special_function */
1287 "R_NDS32_PLT_GOTREL_HI20",/* name */
1288 FALSE, /* partial_inplace */
1289 0x000fffff, /* src_mask */
1290 0x000fffff, /* dst_mask */
1291 FALSE), /* pcrel_offset */
1292
1293 /* Low 12 bits of PLT symbol offset relative to GOT (GP). */
1294 HOWTO2 (R_NDS32_PLT_GOTREL_LO12,/* type */
1295 0, /* rightshift */
1296 2, /* size (0 = byte, 1 = short, 2 = long) */
1297 12, /* bitsize */
1298 FALSE, /* pc_relative */
1299 0, /* bitpos */
1300 complain_overflow_dont,/* complain_on_overflow */
1301 bfd_elf_generic_reloc, /* special_function */
1302 "R_NDS32_PLT_GOTREL_LO12",/* name */
1303 FALSE, /* partial_inplace */
1304 0x00000fff, /* src_mask */
1305 0x00000fff, /* dst_mask */
1306 FALSE), /* pcrel_offset */
1307
1308 /* Small data area 12 bits offset. */
1309 HOWTO2 (R_NDS32_SDA12S2_DP_RELA,/* type */
1310 2, /* rightshift */
1311 2, /* size (0 = byte, 1 = short, 2 = long) */
1312 12, /* bitsize */
1313 FALSE, /* pc_relative */
1314 0, /* bitpos */
1315 complain_overflow_signed,/* complain_on_overflow */
1316 bfd_elf_generic_reloc, /* special_function */
1317 "R_NDS32_SDA12S2_DP_RELA",/* name */
1318 FALSE, /* partial_inplace */
1319 0x00000fff, /* src_mask */
1320 0x00000fff, /* dst_mask */
1321 FALSE), /* pcrel_offset */
1322
1323 /* Small data area 12 bits offset. */
1324 HOWTO2 (R_NDS32_SDA12S2_SP_RELA,/* type */
1325 2, /* rightshift */
1326 2, /* size (0 = byte, 1 = short, 2 = long) */
1327 12, /* bitsize */
1328 FALSE, /* pc_relative */
1329 0, /* bitpos */
1330 complain_overflow_signed,/* complain_on_overflow */
1331 bfd_elf_generic_reloc, /* special_function */
1332 "R_NDS32_SDA12S2_SP_RELA",/* name */
1333 FALSE, /* partial_inplace */
1334 0x00000fff, /* src_mask */
1335 0x00000fff, /* dst_mask */
1336 FALSE), /* pcrel_offset */
1337 /* Lower 12 bits of address. */
1338
1339 HOWTO2 (R_NDS32_LO12S2_DP_RELA, /* type */
1340 2, /* rightshift */
1341 2, /* size (0 = byte, 1 = short, 2 = long) */
1342 10, /* bitsize */
1343 FALSE, /* pc_relative */
1344 0, /* bitpos */
1345 complain_overflow_dont,/* complain_on_overflow */
1346 bfd_elf_generic_reloc, /* special_function */
1347 "R_NDS32_LO12S2_DP_RELA",/* name */
1348 FALSE, /* partial_inplace */
1349 0x000003ff, /* src_mask */
1350 0x000003ff, /* dst_mask */
1351 FALSE), /* pcrel_offset */
1352
1353 /* Lower 12 bits of address. */
1354 HOWTO2 (R_NDS32_LO12S2_SP_RELA,/* type */
1355 2, /* rightshift */
1356 2, /* size (0 = byte, 1 = short, 2 = long) */
1357 10, /* bitsize */
1358 FALSE, /* pc_relative */
1359 0, /* bitpos */
1360 complain_overflow_dont,/* complain_on_overflow */
1361 bfd_elf_generic_reloc, /* special_function */
1362 "R_NDS32_LO12S2_SP_RELA",/* name */
1363 FALSE, /* partial_inplace */
1364 0x000003ff, /* src_mask */
1365 0x000003ff, /* dst_mask */
1366 FALSE), /* pcrel_offset */
1367 /* Lower 12 bits of address. Special identity for or case. */
1368 HOWTO2 (R_NDS32_LO12S0_ORI_RELA,/* type */
1369 0, /* rightshift */
1370 2, /* size (0 = byte, 1 = short, 2 = long) */
1371 12, /* bitsize */
1372 FALSE, /* pc_relative */
1373 0, /* bitpos */
1374 complain_overflow_dont,/* complain_on_overflow */
1375 bfd_elf_generic_reloc, /* special_function */
1376 "R_NDS32_LO12S0_ORI_RELA",/* name */
1377 FALSE, /* partial_inplace */
1378 0x00000fff, /* src_mask */
1379 0x00000fff, /* dst_mask */
1380 FALSE), /* pcrel_offset */
1381 /* Small data area 19 bits offset. */
1382 HOWTO2 (R_NDS32_SDA16S3_RELA, /* type */
1383 3, /* rightshift */
1384 2, /* size (0 = byte, 1 = short, 2 = long) */
1385 16, /* bitsize */
1386 FALSE, /* pc_relative */
1387 0, /* bitpos */
1388 complain_overflow_signed,/* complain_on_overflow */
1389 bfd_elf_generic_reloc, /* special_function */
1390 "R_NDS32_SDA16S3_RELA",/* name */
1391 FALSE, /* partial_inplace */
1392 0x0000ffff, /* src_mask */
1393 0x0000ffff, /* dst_mask */
1394 FALSE), /* pcrel_offset */
1395
1396 /* Small data area 15 bits offset. */
1397 HOWTO2 (R_NDS32_SDA17S2_RELA, /* type */
1398 2, /* rightshift */
1399 2, /* size (0 = byte, 1 = short, 2 = long) */
1400 17, /* bitsize */
1401 FALSE, /* pc_relative */
1402 0, /* bitpos */
1403 complain_overflow_signed,/* complain_on_overflow */
1404 bfd_elf_generic_reloc, /* special_function */
1405 "R_NDS32_SDA17S2_RELA",/* name */
1406 FALSE, /* partial_inplace */
1407 0x0001ffff, /* src_mask */
1408 0x0001ffff, /* dst_mask */
1409 FALSE), /* pcrel_offset */
1410
1411 HOWTO2 (R_NDS32_SDA18S1_RELA, /* type */
1412 1, /* rightshift */
1413 2, /* size (0 = byte, 1 = short, 2 = long) */
1414 18, /* bitsize */
1415 FALSE, /* pc_relative */
1416 0, /* bitpos */
1417 complain_overflow_signed,/* complain_on_overflow */
1418 bfd_elf_generic_reloc, /* special_function */
1419 "R_NDS32_SDA18S1_RELA",/* name */
1420 FALSE, /* partial_inplace */
1421 0x0003ffff, /* src_mask */
1422 0x0003ffff, /* dst_mask */
1423 FALSE), /* pcrel_offset */
1424
1425 HOWTO2 (R_NDS32_SDA19S0_RELA, /* type */
1426 0, /* rightshift */
1427 2, /* size (0 = byte, 1 = short, 2 = long) */
1428 19, /* bitsize */
1429 FALSE, /* pc_relative */
1430 0, /* bitpos */
1431 complain_overflow_signed,/* complain_on_overflow */
1432 bfd_elf_generic_reloc, /* special_function */
1433 "R_NDS32_SDA19S0_RELA",/* name */
1434 FALSE, /* partial_inplace */
1435 0x0007ffff, /* src_mask */
1436 0x0007ffff, /* dst_mask */
1437 FALSE), /* pcrel_offset */
1438 HOWTO2 (R_NDS32_DWARF2_OP1_RELA,/* type */
1439 0, /* rightshift */
1440 0, /* size (0 = byte, 1 = short, 2 = long) */
1441 8, /* bitsize */
1442 FALSE, /* pc_relative */
1443 0, /* bitpos */
1444 complain_overflow_dont,/* complain_on_overflow */
1445 nds32_elf_ignore_reloc,/* special_function */
1446 "R_NDS32_DWARF2_OP1_RELA",/* name */
1447 FALSE, /* partial_inplace */
1448 0xff, /* src_mask */
1449 0xff, /* dst_mask */
1450 FALSE), /* pcrel_offset */
1451 HOWTO2 (R_NDS32_DWARF2_OP2_RELA,/* type */
1452 0, /* rightshift */
1453 1, /* size (0 = byte, 1 = short, 2 = long) */
1454 16, /* bitsize */
1455 FALSE, /* pc_relative */
1456 0, /* bitpos */
1457 complain_overflow_dont,/* complain_on_overflow */
1458 nds32_elf_ignore_reloc,/* special_function */
1459 "R_NDS32_DWARF2_OP2_RELA",/* name */
1460 FALSE, /* partial_inplace */
1461 0xffff, /* src_mask */
1462 0xffff, /* dst_mask */
1463 FALSE), /* pcrel_offset */
1464 HOWTO2 (R_NDS32_DWARF2_LEB_RELA,/* type */
1465 0, /* rightshift */
1466 2, /* size (0 = byte, 1 = short, 2 = long) */
1467 32, /* bitsize */
1468 FALSE, /* pc_relative */
1469 0, /* bitpos */
1470 complain_overflow_dont,/* complain_on_overflow */
1471 nds32_elf_ignore_reloc,/* special_function */
1472 "R_NDS32_DWARF2_LEB_RELA",/* name */
1473 FALSE, /* partial_inplace */
1474 0xffffffff, /* src_mask */
1475 0xffffffff, /* dst_mask */
1476 FALSE), /* pcrel_offset */
1477 HOWTO2 (R_NDS32_UPDATE_TA_RELA,/* type */
1478 0, /* rightshift */
1479 1, /* size (0 = byte, 1 = short, 2 = long) */
1480 16, /* bitsize */
1481 FALSE, /* pc_relative */
1482 0, /* bitpos */
1483 complain_overflow_dont,/* complain_on_overflow */
1484 nds32_elf_ignore_reloc,/* special_function */
1485 "R_NDS32_UPDATE_TA_RELA",/* name */
1486 FALSE, /* partial_inplace */
1487 0xffff, /* src_mask */
1488 0xffff, /* dst_mask */
1489 FALSE), /* pcrel_offset */
1490 /* Like R_NDS32_PCREL, but referring to the procedure linkage table
1491 entry for the symbol. */
1492 HOWTO2 (R_NDS32_9_PLTREL, /* type */
1493 1, /* rightshift */
1494 1, /* size (0 = byte, 1 = short, 2 = long) */
1495 8, /* bitsize */
1496 TRUE, /* pc_relative */
1497 0, /* bitpos */
1498 complain_overflow_signed,/* complain_on_overflow */
1499 bfd_elf_generic_reloc, /* special_function */
1500 "R_NDS32_9_PLTREL", /* name */
1501 FALSE, /* partial_inplace */
1502 0xff, /* src_mask */
1503 0xff, /* dst_mask */
1504 TRUE), /* pcrel_offset */
1505 /* Low 20 bits of PLT symbol offset relative to GOT (GP). */
1506 HOWTO2 (R_NDS32_PLT_GOTREL_LO20,/* type */
1507 0, /* rightshift */
1508 2, /* size (0 = byte, 1 = short, 2 = long) */
1509 20, /* bitsize */
1510 FALSE, /* pc_relative */
1511 0, /* bitpos */
1512 complain_overflow_dont,/* complain_on_overflow */
1513 bfd_elf_generic_reloc, /* special_function */
1514 "R_NDS32_PLT_GOTREL_LO20",/* name */
1515 FALSE, /* partial_inplace */
1516 0x000fffff, /* src_mask */
1517 0x000fffff, /* dst_mask */
1518 FALSE), /* pcrel_offset */
1519 /* low 15 bits of PLT symbol offset relative to GOT (GP) */
1520 HOWTO2 (R_NDS32_PLT_GOTREL_LO15,/* type */
1521 0, /* rightshift */
1522 2, /* size (0 = byte, 1 = short, 2 = long) */
1523 15, /* bitsize */
1524 FALSE, /* pc_relative */
1525 0, /* bitpos */
1526 complain_overflow_dont,/* complain_on_overflow */
1527 bfd_elf_generic_reloc, /* special_function */
1528 "R_NDS32_PLT_GOTREL_LO15",/* name */
1529 FALSE, /* partial_inplace */
1530 0x00007fff, /* src_mask */
1531 0x00007fff, /* dst_mask */
1532 FALSE), /* pcrel_offset */
1533 /* Low 19 bits of PLT symbol offset relative to GOT (GP). */
1534 HOWTO2 (R_NDS32_PLT_GOTREL_LO19,/* type */
1535 0, /* rightshift */
1536 2, /* size (0 = byte, 1 = short, 2 = long) */
1537 19, /* bitsize */
1538 FALSE, /* pc_relative */
1539 0, /* bitpos */
1540 complain_overflow_dont,/* complain_on_overflow */
1541 bfd_elf_generic_reloc, /* special_function */
1542 "R_NDS32_PLT_GOTREL_LO19",/* name */
1543 FALSE, /* partial_inplace */
1544 0x0007ffff, /* src_mask */
1545 0x0007ffff, /* dst_mask */
1546 FALSE), /* pcrel_offset */
1547 HOWTO2 (R_NDS32_GOT_LO15, /* type */
1548 0, /* rightshift */
1549 2, /* size (0 = byte, 1 = short, 2 = long) */
1550 15, /* bitsize */
1551 FALSE, /* pc_relative */
1552 0, /* bitpos */
1553 complain_overflow_dont,/* complain_on_overflow */
1554 bfd_elf_generic_reloc, /* special_function */
1555 "R_NDS32_GOT_LO15", /* name */
1556 FALSE, /* partial_inplace */
1557 0x00007fff, /* src_mask */
1558 0x00007fff, /* dst_mask */
1559 FALSE), /* pcrel_offset */
1560 HOWTO2 (R_NDS32_GOT_LO19, /* type */
1561 0, /* rightshift */
1562 2, /* size (0 = byte, 1 = short, 2 = long) */
1563 19, /* bitsize */
1564 FALSE, /* pc_relative */
1565 0, /* bitpos */
1566 complain_overflow_dont,/* complain_on_overflow */
1567 bfd_elf_generic_reloc, /* special_function */
1568 "R_NDS32_GOT_LO19", /* name */
1569 FALSE, /* partial_inplace */
1570 0x0007ffff, /* src_mask */
1571 0x0007ffff, /* dst_mask */
1572 FALSE), /* pcrel_offset */
1573 HOWTO2 (R_NDS32_GOTOFF_LO15, /* type */
1574 0, /* rightshift */
1575 2, /* size (0 = byte, 1 = short, 2 = long) */
1576 15, /* bitsize */
1577 FALSE, /* pc_relative */
1578 0, /* bitpos */
1579 complain_overflow_dont,/* complain_on_overflow */
1580 bfd_elf_generic_reloc, /* special_function */
1581 "R_NDS32_GOTOFF_LO15", /* name */
1582 FALSE, /* partial_inplace */
1583 0x00007fff, /* src_mask */
1584 0x00007fff, /* dst_mask */
1585 FALSE), /* pcrel_offset */
1586 HOWTO2 (R_NDS32_GOTOFF_LO19, /* type */
1587 0, /* rightshift */
1588 2, /* size (0 = byte, 1 = short, 2 = long) */
1589 19, /* bitsize */
1590 FALSE, /* pc_relative */
1591 0, /* bitpos */
1592 complain_overflow_dont,/* complain_on_overflow */
1593 bfd_elf_generic_reloc, /* special_function */
1594 "R_NDS32_GOTOFF_LO19", /* name */
1595 FALSE, /* partial_inplace */
1596 0x0007ffff, /* src_mask */
1597 0x0007ffff, /* dst_mask */
1598 FALSE), /* pcrel_offset */
1599 /* GOT 15 bits offset. */
1600 HOWTO2 (R_NDS32_GOT15S2_RELA, /* type */
1601 2, /* rightshift */
1602 2, /* size (0 = byte, 1 = short, 2 = long) */
1603 15, /* bitsize */
1604 FALSE, /* pc_relative */
1605 0, /* bitpos */
1606 complain_overflow_signed,/* complain_on_overflow */
1607 bfd_elf_generic_reloc, /* special_function */
1608 "R_NDS32_GOT15S2_RELA",/* name */
1609 FALSE, /* partial_inplace */
1610 0x00007fff, /* src_mask */
1611 0x00007fff, /* dst_mask */
1612 FALSE), /* pcrel_offset */
1613 /* GOT 17 bits offset. */
1614 HOWTO2 (R_NDS32_GOT17S2_RELA, /* type */
1615 2, /* rightshift */
1616 2, /* size (0 = byte, 1 = short, 2 = long) */
1617 17, /* bitsize */
1618 FALSE, /* pc_relative */
1619 0, /* bitpos */
1620 complain_overflow_signed,/* complain_on_overflow */
1621 bfd_elf_generic_reloc, /* special_function */
1622 "R_NDS32_GOT17S2_RELA",/* name */
1623 FALSE, /* partial_inplace */
1624 0x0001ffff, /* src_mask */
1625 0x0001ffff, /* dst_mask */
1626 FALSE), /* pcrel_offset */
1627 /* A 5 bit address. */
1628 HOWTO2 (R_NDS32_5_RELA, /* type */
1629 0, /* rightshift */
1630 1, /* size (0 = byte, 1 = short, 2 = long) */
1631 5, /* bitsize */
1632 FALSE, /* pc_relative */
1633 0, /* bitpos */
1634 complain_overflow_signed,/* complain_on_overflow */
1635 bfd_elf_generic_reloc, /* special_function */
1636 "R_NDS32_5_RELA", /* name */
1637 FALSE, /* partial_inplace */
1638 0x1f, /* src_mask */
1639 0x1f, /* dst_mask */
1640 FALSE), /* pcrel_offset */
1641 HOWTO2 (R_NDS32_10_UPCREL_RELA,/* type */
1642 1, /* rightshift */
1643 1, /* size (0 = byte, 1 = short, 2 = long) */
1644 9, /* bitsize */
1645 TRUE, /* pc_relative */
1646 0, /* bitpos */
1647 complain_overflow_unsigned,/* complain_on_overflow */
1648 bfd_elf_generic_reloc, /* special_function */
1649 "R_NDS32_10_UPCREL_RELA",/* name */
1650 FALSE, /* partial_inplace */
1651 0x1ff, /* src_mask */
1652 0x1ff, /* dst_mask */
1653 TRUE), /* pcrel_offset */
1654 HOWTO2 (R_NDS32_SDA_FP7U2_RELA,/* type */
1655 2, /* rightshift */
1656 1, /* size (0 = byte, 1 = short, 2 = long) */
1657 7, /* bitsize */
1658 FALSE, /* pc_relative */
1659 0, /* bitpos */
1660 complain_overflow_unsigned,/* complain_on_overflow */
1661 bfd_elf_generic_reloc, /* special_function */
1662 "R_NDS32_SDA_FP7U2_RELA",/* name */
1663 FALSE, /* partial_inplace */
1664 0x0000007f, /* src_mask */
1665 0x0000007f, /* dst_mask */
1666 FALSE), /* pcrel_offset */
1667 HOWTO2 (R_NDS32_WORD_9_PCREL_RELA,/* type */
1668 1, /* rightshift */
1669 2, /* size (0 = byte, 1 = short, 2 = long) */
1670 8, /* bitsize */
1671 TRUE, /* pc_relative */
1672 0, /* bitpos */
1673 complain_overflow_signed,/* complain_on_overflow */
1674 bfd_elf_generic_reloc, /* special_function */
1675 "R_NDS32_WORD_9_PCREL_RELA",/* name */
1676 FALSE, /* partial_inplace */
1677 0xff, /* src_mask */
1678 0xff, /* dst_mask */
1679 TRUE), /* pcrel_offset */
1680 HOWTO2 (R_NDS32_25_ABS_RELA, /* type */
1681 1, /* rightshift */
1682 2, /* size (0 = byte, 1 = short, 2 = long) */
1683 24, /* bitsize */
1684 FALSE, /* pc_relative */
1685 0, /* bitpos */
1686 complain_overflow_dont,/* complain_on_overflow */
1687 bfd_elf_generic_reloc, /* special_function */
1688 "R_NDS32_25_ABS_RELA", /* name */
1689 FALSE, /* partial_inplace */
1690 0xffffff, /* src_mask */
1691 0xffffff, /* dst_mask */
1692 FALSE), /* pcrel_offset */
1693
1694 /* A relative 17 bit relocation for ifc, right shifted by 1. */
1695 HOWTO2 (R_NDS32_17IFC_PCREL_RELA,/* type */
1696 1, /* rightshift */
1697 2, /* size (0 = byte, 1 = short, 2 = long) */
1698 16, /* bitsize */
1699 TRUE, /* pc_relative */
1700 0, /* bitpos */
1701 complain_overflow_signed,/* complain_on_overflow */
1702 bfd_elf_generic_reloc, /* special_function */
1703 "R_NDS32_17IFC_PCREL_RELA",/* name */
1704 FALSE, /* partial_inplace */
1705 0xffff, /* src_mask */
1706 0xffff, /* dst_mask */
1707 TRUE), /* pcrel_offset */
1708
1709 /* A relative unsigned 10 bit relocation for ifc, right shifted by 1. */
1710 HOWTO2 (R_NDS32_10IFCU_PCREL_RELA,/* type */
1711 1, /* rightshift */
1712 1, /* size (0 = byte, 1 = short, 2 = long) */
1713 9, /* bitsize */
1714 TRUE, /* pc_relative */
1715 0, /* bitpos */
1716 complain_overflow_unsigned,/* complain_on_overflow */
1717 bfd_elf_generic_reloc, /* special_function */
1718 "R_NDS32_10IFCU_PCREL_RELA",/* name */
1719 FALSE, /* partial_inplace */
1720 0x1ff, /* src_mask */
1721 0x1ff, /* dst_mask */
1722 TRUE), /* pcrel_offset */
1723
1724 /* Like R_NDS32_HI20, but referring to the TLS LE entry for the symbol. */
1725 HOWTO2 (R_NDS32_TLS_LE_HI20, /* type */
1726 12, /* rightshift */
1727 2, /* size (0 = byte, 1 = short, 2 = long) */
1728 20, /* bitsize */
1729 FALSE, /* pc_relative */
1730 0, /* bitpos */
1731 complain_overflow_dont,/* complain_on_overflow */
1732 bfd_elf_generic_reloc, /* special_function */
1733 "R_NDS32_TLS_LE_HI20", /* name */
1734 FALSE, /* partial_inplace */
1735 0x000fffff, /* src_mask */
1736 0x000fffff, /* dst_mask */
1737 FALSE), /* pcrel_offset */
1738
1739 HOWTO2 (R_NDS32_TLS_LE_LO12, /* type */
1740 0, /* rightshift */
1741 2, /* size (0 = byte, 1 = short, 2 = long) */
1742 12, /* bitsize */
1743 FALSE, /* pc_relative */
1744 0, /* bitpos */
1745 complain_overflow_dont,/* complain_on_overflow */
1746 bfd_elf_generic_reloc, /* special_function */
1747 "R_NDS32_TLS_LE_LO12", /* name */
1748 FALSE, /* partial_inplace */
1749 0x00000fff, /* src_mask */
1750 0x00000fff, /* dst_mask */
1751 FALSE), /* pcrel_offset */
1752
1753 /* Like R_NDS32_HI20, but referring to the TLS IE entry for the symbol. */
1754 HOWTO2 (R_NDS32_TLS_IE_HI20, /* type */
1755 12, /* rightshift */
1756 2, /* size (0 = byte, 1 = short, 2 = long) */
1757 20, /* bitsize */
1758 FALSE, /* pc_relative */
1759 0, /* bitpos */
1760 complain_overflow_dont,/* complain_on_overflow */
1761 bfd_elf_generic_reloc, /* special_function */
1762 "R_NDS32_TLS_IE_HI20", /* name */
1763 FALSE, /* partial_inplace */
1764 0x000fffff, /* src_mask */
1765 0x000fffff, /* dst_mask */
1766 FALSE), /* pcrel_offset */
1767
1768 HOWTO2 (R_NDS32_TLS_IE_LO12S2,/* type */
1769 2, /* rightshift */
1770 2, /* size (0 = byte, 1 = short, 2 = long) */
1771 10, /* bitsize */
1772 FALSE, /* pc_relative */
1773 0, /* bitpos */
1774 complain_overflow_dont,/* complain_on_overflow */
1775 bfd_elf_generic_reloc, /* special_function */
1776 "R_NDS32_TLS_IE_LO12S2",/* name */
1777 FALSE, /* partial_inplace */
1778 0x000003ff, /* src_mask */
1779 0x000003ff, /* dst_mask */
1780 FALSE), /* pcrel_offset */
1781
1782 /* TLS LE TP offset relocation */
1783 HOWTO2 (R_NDS32_TLS_TPOFF, /* type */
1784 0, /* rightshift */
1785 2, /* size (0 = byte, 1 = short, 2 = long) */
1786 32, /* bitsize */
1787 FALSE, /* pc_relative */
1788 0, /* bitpos */
1789 complain_overflow_bitfield,/* complain_on_overflow */
1790 bfd_elf_generic_reloc, /* special_function */
1791 "R_NDS32_TLS_TPOFF", /* name */
1792 FALSE, /* partial_inplace */
1793 0xffffffff, /* src_mask */
1794 0xffffffff, /* dst_mask */
1795 FALSE), /* pcrel_offset */
1796
1797 /* A 20 bit address. */
1798 HOWTO2 (R_NDS32_TLS_LE_20, /* type */
1799 0, /* rightshift */
1800 2, /* size (0 = byte, 1 = short, 2 = long) */
1801 20, /* bitsize */
1802 FALSE, /* pc_relative */
1803 0, /* bitpos */
1804 complain_overflow_signed,/* complain_on_overflow */
1805 bfd_elf_generic_reloc, /* special_function */
1806 "R_NDS32_TLS_LE_20", /* name */
1807 FALSE, /* partial_inplace */
1808 0xfffff, /* src_mask */
1809 0xfffff, /* dst_mask */
1810 FALSE), /* pcrel_offset */
1811
1812 HOWTO2 (R_NDS32_TLS_LE_15S0, /* type */
1813 0, /* rightshift */
1814 2, /* size (0 = byte, 1 = short, 2 = long) */
1815 15, /* bitsize */
1816 FALSE, /* pc_relative */
1817 0, /* bitpos */
1818 complain_overflow_signed,/* complain_on_overflow */
1819 bfd_elf_generic_reloc, /* special_function */
1820 "R_NDS32_TLS_LE_15S0", /* name */
1821 FALSE, /* partial_inplace */
1822 0x7fff, /* src_mask */
1823 0x7fff, /* dst_mask */
1824 FALSE), /* pcrel_offset */
1825 HOWTO2 (R_NDS32_TLS_LE_15S1, /* type */
1826 1, /* rightshift */
1827 2, /* size (0 = byte, 1 = short, 2 = long) */
1828 15, /* bitsize */
1829 FALSE, /* pc_relative */
1830 0, /* bitpos */
1831 complain_overflow_signed,/* complain_on_overflow */
1832 bfd_elf_generic_reloc, /* special_function */
1833 "R_NDS32_TLS_LE_15S1", /* name */
1834 FALSE, /* partial_inplace */
1835 0x7fff, /* src_mask */
1836 0x7fff, /* dst_mask */
1837 FALSE), /* pcrel_offset */
1838 HOWTO2 (R_NDS32_TLS_LE_15S2, /* type */
1839 2, /* rightshift */
1840 2, /* size (0 = byte, 1 = short, 2 = long) */
1841 15, /* bitsize */
1842 FALSE, /* pc_relative */
1843 0, /* bitpos */
1844 complain_overflow_signed,/* complain_on_overflow */
1845 bfd_elf_generic_reloc, /* special_function */
1846 "R_NDS32_TLS_LE_15S2", /* name */
1847 FALSE, /* partial_inplace */
1848 0x7fff, /* src_mask */
1849 0x7fff, /* dst_mask */
1850 FALSE), /* pcrel_offset */
1851
1852 /* Relax hint for unconditional call sequence */
1853 HOWTO2 (R_NDS32_LONGCALL4, /* type */
1854 0, /* rightshift */
1855 2, /* size (0 = byte, 1 = short, 2 = long) */
1856 32, /* bitsize */
1857 FALSE, /* pc_relative */
1858 0, /* bitpos */
1859 complain_overflow_dont,/* complain_on_overflow */
1860 nds32_elf_ignore_reloc,/* special_function */
1861 "R_NDS32_LONGCALL4", /* name */
1862 FALSE, /* partial_inplace */
1863 0xffffffff, /* src_mask */
1864 0xffffffff, /* dst_mask */
1865 FALSE), /* pcrel_offset */
1866
1867 /* Relax hint for conditional call sequence. */
1868 HOWTO2 (R_NDS32_LONGCALL5, /* type */
1869 0, /* rightshift */
1870 2, /* size (0 = byte, 1 = short, 2 = long) */
1871 32, /* bitsize */
1872 FALSE, /* pc_relative */
1873 0, /* bitpos */
1874 complain_overflow_dont,/* complain_on_overflow */
1875 nds32_elf_ignore_reloc,/* special_function */
1876 "R_NDS32_LONGCALL5", /* name */
1877 FALSE, /* partial_inplace */
1878 0xffffffff, /* src_mask */
1879 0xffffffff, /* dst_mask */
1880 FALSE), /* pcrel_offset */
1881
1882 /* Relax hint for conditional call sequence. */
1883 HOWTO2 (R_NDS32_LONGCALL6, /* type */
1884 0, /* rightshift */
1885 2, /* size (0 = byte, 1 = short, 2 = long) */
1886 32, /* bitsize */
1887 FALSE, /* pc_relative */
1888 0, /* bitpos */
1889 complain_overflow_dont,/* complain_on_overflow */
1890 nds32_elf_ignore_reloc,/* special_function */
1891 "R_NDS32_LONGCALL6", /* name */
1892 FALSE, /* partial_inplace */
1893 0xffffffff, /* src_mask */
1894 0xffffffff, /* dst_mask */
1895 FALSE), /* pcrel_offset */
1896
1897 /* Relax hint for unconditional branch sequence. */
1898 HOWTO2 (R_NDS32_LONGJUMP4, /* 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_LONGJUMP4", /* name */
1907 FALSE, /* partial_inplace */
1908 0xffffffff, /* src_mask */
1909 0xffffffff, /* dst_mask */
1910 FALSE), /* pcrel_offset */
1911
1912 /* Relax hint for conditional branch sequence. */
1913 HOWTO2 (R_NDS32_LONGJUMP5, /* 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_LONGJUMP5", /* name */
1922 FALSE, /* partial_inplace */
1923 0xffffffff, /* src_mask */
1924 0xffffffff, /* dst_mask */
1925 FALSE), /* pcrel_offset */
1926
1927 /* Relax hint for conditional branch sequence. */
1928 HOWTO2 (R_NDS32_LONGJUMP6, /* 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_LONGJUMP6", /* name */
1937 FALSE, /* partial_inplace */
1938 0xffffffff, /* src_mask */
1939 0xffffffff, /* dst_mask */
1940 FALSE), /* pcrel_offset */
1941
1942 /* Relax hint for conditional branch sequence. */
1943 HOWTO2 (R_NDS32_LONGJUMP7, /* 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_LONGJUMP7", /* name */
1952 FALSE, /* partial_inplace */
1953 0xffffffff, /* src_mask */
1954 0xffffffff, /* dst_mask */
1955 FALSE), /* pcrel_offset */
1956
1957 HOWTO2 (R_NDS32_TLS_IE_LO12, /* type */
1958 0, /* rightshift */
1959 2, /* size (0 = byte, 1 = short, 2 = long) */
1960 12, /* bitsize */
1961 FALSE, /* pc_relative */
1962 0, /* bitpos */
1963 complain_overflow_dont,/* complain_on_overflow */
1964 bfd_elf_generic_reloc, /* special_function */
1965 "R_NDS32_TLS_IE_LO12", /* name */
1966 FALSE, /* partial_inplace */
1967 0x00000fff, /* src_mask */
1968 0x00000fff, /* dst_mask */
1969 FALSE), /* pcrel_offset */
1970
1971 /* Like R_NDS32_HI20, but referring to the TLS IE (PIE)
1972 entry for the symbol. */
1973 HOWTO2 (R_NDS32_TLS_IEGP_HI20,/* type */
1974 12, /* rightshift */
1975 2, /* size (0 = byte, 1 = short, 2 = long) */
1976 20, /* bitsize */
1977 FALSE, /* pc_relative */
1978 0, /* bitpos */
1979 complain_overflow_dont,/* complain_on_overflow */
1980 bfd_elf_generic_reloc, /* special_function */
1981 "R_NDS32_TLS_IEGP_HI20",/* name */
1982 FALSE, /* partial_inplace */
1983 0x000fffff, /* src_mask */
1984 0x000fffff, /* dst_mask */
1985 FALSE), /* pcrel_offset */
1986
1987 HOWTO2 (R_NDS32_TLS_IEGP_LO12,/* type */
1988 0, /* rightshift */
1989 2, /* size (0 = byte, 1 = short, 2 = long) */
1990 12, /* bitsize */
1991 FALSE, /* pc_relative */
1992 0, /* bitpos */
1993 complain_overflow_dont,/* complain_on_overflow */
1994 bfd_elf_generic_reloc, /* special_function */
1995 "R_NDS32_TLS_IEGP_LO12",/* name */
1996 FALSE, /* partial_inplace */
1997 0x00000fff, /* src_mask */
1998 0x00000fff, /* dst_mask */
1999 FALSE), /* pcrel_offset */
2000
2001 HOWTO2 (R_NDS32_TLS_IEGP_LO12S2,/* type */
2002 2, /* rightshift */
2003 2, /* size (0 = byte, 1 = short, 2 = long) */
2004 10, /* bitsize */
2005 FALSE, /* pc_relative */
2006 0, /* bitpos */
2007 complain_overflow_dont,/* complain_on_overflow */
2008 bfd_elf_generic_reloc, /* special_function */
2009 "R_NDS32_TLS_IEGP_LO12S2",/* name */
2010 FALSE, /* partial_inplace */
2011 0x000003ff, /* src_mask */
2012 0x000003ff, /* dst_mask */
2013 FALSE), /* pcrel_offset */
2014
2015 /* TLS description relocation */
2016 HOWTO2 (R_NDS32_TLS_DESC, /* type */
2017 12, /* rightshift */
2018 2, /* size (0 = byte, 1 = short, 2 = long) */
2019 20, /* bitsize */
2020 FALSE, /* pc_relative */
2021 0, /* bitpos */
2022 complain_overflow_dont,/* complain_on_overflow */
2023 nds32_elf_hi20_reloc, /* special_function */
2024 "R_NDS32_TLS_DESC_HI20",/* name */
2025 FALSE, /* partial_inplace */
2026 0x000fffff, /* src_mask */
2027 0x000fffff, /* dst_mask */
2028 FALSE), /* pcrel_offset */
2029
2030 /* TLS GD/LD description offset high part. */
2031 HOWTO2 (R_NDS32_TLS_DESC_HI20,/* type */
2032 12, /* rightshift */
2033 2, /* size (0 = byte, 1 = short, 2 = long) */
2034 20, /* bitsize */
2035 FALSE, /* pc_relative */
2036 0, /* bitpos */
2037 complain_overflow_dont,/* complain_on_overflow */
2038 nds32_elf_hi20_reloc, /* special_function */
2039 "R_NDS32_TLS_DESC_HI20",/* name */
2040 FALSE, /* partial_inplace */
2041 0x000fffff, /* src_mask */
2042 0x000fffff, /* dst_mask */
2043 FALSE), /* pcrel_offset */
2044
2045 /* TLS GD/LD description offset low part. */
2046 HOWTO2 (R_NDS32_TLS_DESC_LO12,/* type */
2047 0, /* rightshift */
2048 2, /* size (0 = byte, 1 = short, 2 = long) */
2049 12, /* bitsize */
2050 FALSE, /* pc_relative */
2051 0, /* bitpos */
2052 complain_overflow_dont,/* complain_on_overflow */
2053 nds32_elf_lo12_reloc, /* special_function */
2054 "R_NDS32_TLS_DESC_LO12",/* name */
2055 FALSE, /* partial_inplace */
2056 0x00000fff, /* src_mask */
2057 0x00000fff, /* dst_mask */
2058 FALSE), /* pcrel_offset */
2059
2060 /* TLS GD/LD description offset set (movi). */
2061 HOWTO2 (R_NDS32_TLS_DESC_20, /* type */
2062 0, /* rightshift */
2063 2, /* size (0 = byte, 1 = short, 2 = long) */
2064 20, /* bitsize */
2065 FALSE, /* pc_relative */
2066 0, /* bitpos */
2067 complain_overflow_signed,/* complain_on_overflow */
2068 bfd_elf_generic_reloc, /* special_function */
2069 "R_NDS32_TLS_DESC_20", /* name */
2070 FALSE, /* partial_inplace */
2071 0x000fffff, /* src_mask */
2072 0x000fffff, /* dst_mask */
2073 FALSE), /* pcrel_offset */
2074
2075 /* TLS GD/LD description offset set (lwi.gp). */
2076 HOWTO2 (R_NDS32_TLS_DESC_SDA17S2,/* type */
2077 2, /* rightshift */
2078 2, /* size (0 = byte, 1 = short, 2 = long) */
2079 17, /* bitsize */
2080 FALSE, /* pc_relative */
2081 0, /* bitpos */
2082 complain_overflow_signed,/* complain_on_overflow */
2083 bfd_elf_generic_reloc, /* special_function */
2084 "R_NDS32_TLS_DESC_SDA17S2",/* name */
2085 FALSE, /* partial_inplace */
2086 0x0001ffff, /* src_mask */
2087 0x0001ffff, /* dst_mask */
2088 FALSE), /* pcrel_offset */
2089 };
2090
2091 /* Relocations used for relaxation. */
2092 #define HOWTO3(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
2093 [C-R_NDS32_RELAX_ENTRY] = HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC)
2094
2095 static reloc_howto_type nds32_elf_relax_howto_table[] = {
2096 HOWTO3 (R_NDS32_RELAX_ENTRY, /* type */
2097 0, /* rightshift */
2098 2, /* size (0 = byte, 1 = short, 2 = long) */
2099 32, /* bitsize */
2100 FALSE, /* pc_relative */
2101 0, /* bitpos */
2102 complain_overflow_dont,/* complain_on_overflow */
2103 nds32_elf_ignore_reloc,/* special_function */
2104 "R_NDS32_RELAX_ENTRY", /* name */
2105 FALSE, /* partial_inplace */
2106 0xffffffff, /* src_mask */
2107 0xffffffff, /* dst_mask */
2108 FALSE), /* pcrel_offset */
2109 HOWTO3 (R_NDS32_GOT_SUFF, /* type */
2110 0, /* rightshift */
2111 2, /* size (0 = byte, 1 = short, 2 = long) */
2112 32, /* bitsize */
2113 FALSE, /* pc_relative */
2114 0, /* bitpos */
2115 complain_overflow_dont,/* complain_on_overflow */
2116 nds32_elf_ignore_reloc,/* special_function */
2117 "R_NDS32_GOT_SUFF", /* name */
2118 FALSE, /* partial_inplace */
2119 0xffffffff, /* src_mask */
2120 0xffffffff, /* dst_mask */
2121 FALSE), /* pcrel_offset */
2122 HOWTO3 (R_NDS32_GOTOFF_SUFF, /* type */
2123 0, /* rightshift */
2124 2, /* size (0 = byte, 1 = short, 2 = long) */
2125 32, /* bitsize */
2126 FALSE, /* pc_relative */
2127 0, /* bitpos */
2128 complain_overflow_bitfield,/* complain_on_overflow */
2129 nds32_elf_ignore_reloc,/* special_function */
2130 "R_NDS32_GOTOFF_SUFF", /* name */
2131 FALSE, /* partial_inplace */
2132 0xffffffff, /* src_mask */
2133 0xffffffff, /* dst_mask */
2134 FALSE), /* pcrel_offset */
2135 HOWTO3 (R_NDS32_PLT_GOT_SUFF, /* type */
2136 0, /* rightshift */
2137 2, /* size (0 = byte, 1 = short, 2 = long) */
2138 32, /* bitsize */
2139 FALSE, /* pc_relative */
2140 0, /* bitpos */
2141 complain_overflow_dont,/* complain_on_overflow */
2142 nds32_elf_ignore_reloc,/* special_function */
2143 "R_NDS32_PLT_GOT_SUFF",/* name */
2144 FALSE, /* partial_inplace */
2145 0xffffffff, /* src_mask */
2146 0xffffffff, /* dst_mask */
2147 FALSE), /* pcrel_offset */
2148 HOWTO3 (R_NDS32_MULCALL_SUFF, /* type */
2149 0, /* rightshift */
2150 2, /* size (0 = byte, 1 = short, 2 = long) */
2151 32, /* bitsize */
2152 FALSE, /* pc_relative */
2153 0, /* bitpos */
2154 complain_overflow_dont,/* complain_on_overflow */
2155 nds32_elf_ignore_reloc,/* special_function */
2156 "R_NDS32_MULCALL_SUFF",/* name */
2157 FALSE, /* partial_inplace */
2158 0xffffffff, /* src_mask */
2159 0xffffffff, /* dst_mask */
2160 FALSE), /* pcrel_offset */
2161 HOWTO3 (R_NDS32_PTR, /* type */
2162 0, /* rightshift */
2163 2, /* size (0 = byte, 1 = short, 2 = long) */
2164 32, /* bitsize */
2165 FALSE, /* pc_relative */
2166 0, /* bitpos */
2167 complain_overflow_dont,/* complain_on_overflow */
2168 nds32_elf_ignore_reloc,/* special_function */
2169 "R_NDS32_PTR", /* name */
2170 FALSE, /* partial_inplace */
2171 0xffffffff, /* src_mask */
2172 0xffffffff, /* dst_mask */
2173 FALSE), /* pcrel_offset */
2174 HOWTO3 (R_NDS32_PTR_COUNT, /* type */
2175 0, /* rightshift */
2176 2, /* size (0 = byte, 1 = short, 2 = long) */
2177 32, /* bitsize */
2178 FALSE, /* pc_relative */
2179 0, /* bitpos */
2180 complain_overflow_dont,/* complain_on_overflow */
2181 nds32_elf_ignore_reloc,/* special_function */
2182 "R_NDS32_PTR_COUNT", /* name */
2183 FALSE, /* partial_inplace */
2184 0xffffffff, /* src_mask */
2185 0xffffffff, /* dst_mask */
2186 FALSE), /* pcrel_offset */
2187 HOWTO3 (R_NDS32_PTR_RESOLVED, /* type */
2188 0, /* rightshift */
2189 2, /* size (0 = byte, 1 = short, 2 = long) */
2190 32, /* bitsize */
2191 FALSE, /* pc_relative */
2192 0, /* bitpos */
2193 complain_overflow_dont,/* complain_on_overflow */
2194 nds32_elf_ignore_reloc,/* special_function */
2195 "R_NDS32_PTR_RESOLVED",/* name */
2196 FALSE, /* partial_inplace */
2197 0xffffffff, /* src_mask */
2198 0xffffffff, /* dst_mask */
2199 FALSE), /* pcrel_offset */
2200 HOWTO3 (R_NDS32_PLTBLOCK, /* type */
2201 0, /* rightshift */
2202 2, /* size (0 = byte, 1 = short, 2 = long) */
2203 32, /* bitsize */
2204 FALSE, /* pc_relative */
2205 0, /* bitpos */
2206 complain_overflow_dont,/* complain_on_overflow */
2207 nds32_elf_ignore_reloc,/* special_function */
2208 "R_NDS32_PLTBLOCK", /* name */
2209 FALSE, /* partial_inplace */
2210 0xffffffff, /* src_mask */
2211 0xffffffff, /* dst_mask */
2212 FALSE), /* pcrel_offset */
2213 HOWTO3 (R_NDS32_RELAX_REGION_BEGIN,/* type */
2214 0, /* rightshift */
2215 2, /* size (0 = byte, 1 = short, 2 = long) */
2216 32, /* bitsize */
2217 FALSE, /* pc_relative */
2218 0, /* bitpos */
2219 complain_overflow_dont,/* complain_on_overflow */
2220 nds32_elf_ignore_reloc,/* special_function */
2221 "R_NDS32_RELAX_REGION_BEGIN",/* name */
2222 FALSE, /* partial_inplace */
2223 0xffffffff, /* src_mask */
2224 0xffffffff, /* dst_mask */
2225 FALSE), /* pcrel_offset */
2226 HOWTO3 (R_NDS32_RELAX_REGION_END,/* type */
2227 0, /* rightshift */
2228 2, /* size (0 = byte, 1 = short, 2 = long) */
2229 32, /* bitsize */
2230 FALSE, /* pc_relative */
2231 0, /* bitpos */
2232 complain_overflow_dont,/* complain_on_overflow */
2233 nds32_elf_ignore_reloc,/* special_function */
2234 "R_NDS32_RELAX_REGION_END",/* name */
2235 FALSE, /* partial_inplace */
2236 0xffffffff, /* src_mask */
2237 0xffffffff, /* dst_mask */
2238 FALSE), /* pcrel_offset */
2239 HOWTO3 (R_NDS32_MINUEND, /* type */
2240 0, /* rightshift */
2241 2, /* size (0 = byte, 1 = short, 2 = long) */
2242 32, /* bitsize */
2243 FALSE, /* pc_relative */
2244 0, /* bitpos */
2245 complain_overflow_dont,/* complain_on_overflow */
2246 nds32_elf_ignore_reloc,/* special_function */
2247 "R_NDS32_MINUEND", /* name */
2248 FALSE, /* partial_inplace */
2249 0xffffffff, /* src_mask */
2250 0xffffffff, /* dst_mask */
2251 FALSE), /* pcrel_offset */
2252 HOWTO3 (R_NDS32_SUBTRAHEND, /* type */
2253 0, /* rightshift */
2254 2, /* size (0 = byte, 1 = short, 2 = long) */
2255 32, /* bitsize */
2256 FALSE, /* pc_relative */
2257 0, /* bitpos */
2258 complain_overflow_dont,/* complain_on_overflow */
2259 nds32_elf_ignore_reloc,/* special_function */
2260 "R_NDS32_SUBTRAHEND", /* name */
2261 FALSE, /* partial_inplace */
2262 0xffffffff, /* src_mask */
2263 0xffffffff, /* dst_mask */
2264 FALSE), /* pcrel_offset */
2265 HOWTO3 (R_NDS32_DIFF8, /* type */
2266 0, /* rightshift */
2267 0, /* size (0 = byte, 1 = short, 2 = long) */
2268 8, /* bitsize */
2269 FALSE, /* pc_relative */
2270 0, /* bitpos */
2271 complain_overflow_dont,/* complain_on_overflow */
2272 nds32_elf_ignore_reloc,/* special_function */
2273 "R_NDS32_DIFF8", /* name */
2274 FALSE, /* partial_inplace */
2275 0x000000ff, /* src_mask */
2276 0x000000ff, /* dst_mask */
2277 FALSE), /* pcrel_offset */
2278 HOWTO3 (R_NDS32_DIFF16, /* type */
2279 0, /* rightshift */
2280 1, /* size (0 = byte, 1 = short, 2 = long) */
2281 16, /* bitsize */
2282 FALSE, /* pc_relative */
2283 0, /* bitpos */
2284 complain_overflow_dont,/* complain_on_overflow */
2285 nds32_elf_ignore_reloc,/* special_function */
2286 "R_NDS32_DIFF16", /* name */
2287 FALSE, /* partial_inplace */
2288 0x0000ffff, /* src_mask */
2289 0x0000ffff, /* dst_mask */
2290 FALSE), /* pcrel_offset */
2291 HOWTO3 (R_NDS32_DIFF32, /* type */
2292 0, /* rightshift */
2293 2, /* size (0 = byte, 1 = short, 2 = long) */
2294 32, /* bitsize */
2295 FALSE, /* pc_relative */
2296 0, /* bitpos */
2297 complain_overflow_dont,/* complain_on_overflow */
2298 nds32_elf_ignore_reloc,/* special_function */
2299 "R_NDS32_DIFF32", /* name */
2300 FALSE, /* partial_inplace */
2301 0xffffffff, /* src_mask */
2302 0xffffffff, /* dst_mask */
2303 FALSE), /* pcrel_offset */
2304 HOWTO3 (R_NDS32_DIFF_ULEB128, /* type */
2305 0, /* rightshift */
2306 0, /* size (0 = byte, 1 = short, 2 = long) */
2307 0, /* bitsize */
2308 FALSE, /* pc_relative */
2309 0, /* bitpos */
2310 complain_overflow_dont,/* complain_on_overflow */
2311 nds32_elf_ignore_reloc,/* special_function */
2312 "R_NDS32_DIFF_ULEB128",/* name */
2313 FALSE, /* partial_inplace */
2314 0xffffffff, /* src_mask */
2315 0xffffffff, /* dst_mask */
2316 FALSE), /* pcrel_offset */
2317 HOWTO3 (R_NDS32_DATA, /* type */
2318 0, /* rightshift */
2319 2, /* size (0 = byte, 1 = short, 2 = long) */
2320 32, /* bitsize */
2321 FALSE, /* pc_relative */
2322 0, /* bitpos */
2323 complain_overflow_dont,/* complain_on_overflow */
2324 nds32_elf_ignore_reloc,/* special_function */
2325 "R_NDS32_DATA", /* name */
2326 FALSE, /* partial_inplace */
2327 0xffffffff, /* src_mask */
2328 0xffffffff, /* dst_mask */
2329 FALSE), /* pcrel_offset */
2330 HOWTO3 (R_NDS32_TRAN, /* type */
2331 0, /* rightshift */
2332 2, /* size (0 = byte, 1 = short, 2 = long) */
2333 32, /* bitsize */
2334 FALSE, /* pc_relative */
2335 0, /* bitpos */
2336 complain_overflow_dont,/* complain_on_overflow */
2337 nds32_elf_ignore_reloc,/* special_function */
2338 "R_NDS32_TRAN", /* name */
2339 FALSE, /* partial_inplace */
2340 0xffffffff, /* src_mask */
2341 0xffffffff, /* dst_mask */
2342 FALSE), /* pcrel_offset */
2343 HOWTO3 (R_NDS32_TLS_LE_ADD, /* type */
2344 0, /* rightshift */
2345 2, /* size (0 = byte, 1 = short, 2 = long) */
2346 32, /* bitsize */
2347 FALSE, /* pc_relative */
2348 0, /* bitpos */
2349 complain_overflow_dont,/* complain_on_overflow */
2350 nds32_elf_ignore_reloc,/* special_function */
2351 "R_NDS32_TLS_LE_ADD", /* name */
2352 FALSE, /* partial_inplace */
2353 0xffffffff, /* src_mask */
2354 0xffffffff, /* dst_mask */
2355 FALSE), /* pcrel_offset */
2356 HOWTO3 (R_NDS32_TLS_LE_LS, /* type */
2357 0, /* rightshift */
2358 2, /* size (0 = byte, 1 = short, 2 = long) */
2359 32, /* bitsize */
2360 FALSE, /* pc_relative */
2361 0, /* bitpos */
2362 complain_overflow_dont,/* complain_on_overflow */
2363 nds32_elf_ignore_reloc,/* special_function */
2364 "R_NDS32_TLS_LE_LS", /* name */
2365 FALSE, /* partial_inplace */
2366 0xffffffff, /* src_mask */
2367 0xffffffff, /* dst_mask */
2368 FALSE), /* pcrel_offset */
2369 HOWTO3 (R_NDS32_EMPTY, /* type */
2370 0, /* rightshift */
2371 2, /* size (0 = byte, 1 = short, 2 = long) */
2372 32, /* bitsize */
2373 FALSE, /* pc_relative */
2374 0, /* bitpos */
2375 complain_overflow_dont,/* complain_on_overflow */
2376 nds32_elf_ignore_reloc,/* special_function */
2377 "R_NDS32_EMPTY", /* name */
2378 FALSE, /* partial_inplace */
2379 0xffffffff, /* src_mask */
2380 0xffffffff, /* dst_mask */
2381 FALSE), /* pcrel_offset */
2382 /* TLS GD/LD description address base addition. */
2383 HOWTO3 (R_NDS32_TLS_DESC_ADD, /* type */
2384 0, /* rightshift */
2385 2, /* size (0 = byte, 1 = short, 2 = long) */
2386 32, /* bitsize */
2387 FALSE, /* pc_relative */
2388 0, /* bitpos */
2389 complain_overflow_dont,/* complain_on_overflow */
2390 nds32_elf_ignore_reloc,/* special_function */
2391 "R_NDS32_TLS_DESC_ADD",/* name */
2392 FALSE, /* partial_inplace */
2393 0xffffffff, /* src_mask */
2394 0xffffffff, /* dst_mask */
2395 FALSE), /* pcrel_offset */
2396 /* TLS GD/LD description function load. */
2397 HOWTO3 (R_NDS32_TLS_DESC_FUNC,/* type */
2398 0, /* rightshift */
2399 2, /* size (0 = byte, 1 = short, 2 = long) */
2400 32, /* bitsize */
2401 FALSE, /* pc_relative */
2402 0, /* bitpos */
2403 complain_overflow_dont,/* complain_on_overflow */
2404 nds32_elf_ignore_reloc,/* special_function */
2405 "R_NDS32_TLS_DESC_FUNC",/* name */
2406 FALSE, /* partial_inplace */
2407 0xffffffff, /* src_mask */
2408 0xffffffff, /* dst_mask */
2409 FALSE), /* pcrel_offset */
2410 /* TLS DESC resolve function call. */
2411 HOWTO3 (R_NDS32_TLS_DESC_CALL,/* type */
2412 0, /* rightshift */
2413 2, /* size (0 = byte, 1 = short, 2 = long) */
2414 32, /* bitsize */
2415 FALSE, /* pc_relative */
2416 0, /* bitpos */
2417 complain_overflow_dont,/* complain_on_overflow */
2418 nds32_elf_ignore_reloc,/* special_function */
2419 "R_NDS32_TLS_DESC_CALL",/* name */
2420 FALSE, /* partial_inplace */
2421 0xffffffff, /* src_mask */
2422 0xffffffff, /* dst_mask */
2423 FALSE), /* pcrel_offset */
2424 /* TLS DESC variable access. */
2425 HOWTO3 (R_NDS32_TLS_DESC_MEM, /* type */
2426 0, /* rightshift */
2427 2, /* size (0 = byte, 1 = short, 2 = long) */
2428 32, /* bitsize */
2429 FALSE, /* pc_relative */
2430 0, /* bitpos */
2431 complain_overflow_dont,/* complain_on_overflow */
2432 nds32_elf_ignore_reloc,/* special_function */
2433 "R_NDS32_TLS_DESC_MEM",/* name */
2434 FALSE, /* partial_inplace */
2435 0xffffffff, /* src_mask */
2436 0xffffffff, /* dst_mask */
2437 FALSE), /* pcrel_offset */
2438 /* TLS GD/LD description mark (@tlsdec). */
2439 HOWTO3 (R_NDS32_RELAX_REMOVE, /* type */
2440 0, /* rightshift */
2441 2, /* size (0 = byte, 1 = short, 2 = long) */
2442 32, /* bitsize */
2443 FALSE, /* pc_relative */
2444 0, /* bitpos */
2445 complain_overflow_dont,/* complain_on_overflow */
2446 nds32_elf_ignore_reloc,/* special_function */
2447 "R_NDS32_REMOVE", /* name */
2448 FALSE, /* partial_inplace */
2449 0xffffffff, /* src_mask */
2450 0xffffffff, /* dst_mask */
2451 FALSE), /* pcrel_offset */
2452 /* TLS GD/LD description mark (@tlsdec). */
2453 HOWTO3 (R_NDS32_RELAX_GROUP, /* type */
2454 0, /* rightshift */
2455 2, /* size (0 = byte, 1 = short, 2 = long) */
2456 32, /* bitsize */
2457 FALSE, /* pc_relative */
2458 0, /* bitpos */
2459 complain_overflow_dont,/* complain_on_overflow */
2460 nds32_elf_ignore_reloc,/* special_function */
2461 "R_NDS32_GROUP", /* name */
2462 FALSE, /* partial_inplace */
2463 0xffffffff, /* src_mask */
2464 0xffffffff, /* dst_mask */
2465 FALSE), /* pcrel_offset */
2466 HOWTO3 (R_NDS32_TLS_IEGP_LW, /* type */
2467 0, /* rightshift */
2468 2, /* size (0 = byte, 1 = short, 2 = long) */
2469 32, /* bitsize */
2470 FALSE, /* pc_relative */
2471 0, /* bitpos */
2472 complain_overflow_dont,/* complain_on_overflow */
2473 nds32_elf_ignore_reloc,/* special_function */
2474 "R_NDS32_TLS_IEGP_LW", /* name */
2475 FALSE, /* partial_inplace */
2476 0xffffffff, /* src_mask */
2477 0xffffffff, /* dst_mask */
2478 FALSE), /* pcrel_offset */
2479 /* LA and FLSI relaxation. */
2480 HOWTO3 (R_NDS32_LSI, /* type */
2481 0, /* rightshift */
2482 2, /* size (0 = byte, 1 = short, 2 = long) */
2483 32, /* bitsize */
2484 FALSE, /* pc_relative */
2485 0, /* bitpos */
2486 complain_overflow_dont,/* complain_on_overflow */
2487 nds32_elf_ignore_reloc,/* special_function */
2488 "R_NDS32_LSI", /* name */
2489 FALSE, /* partial_inplace */
2490 0xffffffff, /* src_mask */
2491 0xffffffff, /* dst_mask */
2492 FALSE),
2493 };
2494
2495 static unsigned long dl_tlsdesc_lazy_trampoline[] =
2496 {
2497 0x46200000, /* sethi $r2,#0x0 */
2498 0x58210000, /* ori $r2,$r2,#0x0 */
2499 0x40217400, /* add $r2,$r2,$gp */
2500 0x04210000, /* lwi $r2,[$r2+#0x0] */
2501 0x46300000, /* sethi $r3,#0x0 */
2502 0x58318000, /* ori $r3,$r3,#0x0 */
2503 0x4031f400, /* add $r3,$r3,$gp */
2504 0x4a000800, /* jr $r2 */
2505 };
2506
2507 static void
2508 nds32_put_trampoline (void *contents, const unsigned long *template,
2509 unsigned count)
2510 {
2511 unsigned ix;
2512
2513 for (ix = 0; ix != count; ix++)
2514 {
2515 unsigned long insn = template[ix];
2516 bfd_putb32 (insn, (char *) contents + ix * 4);
2517 }
2518 }
2519
2520 /* nds32_insertion_sort sorts an array with nmemb elements of size size.
2521 This prototype is the same as qsort (). */
2522
2523 void
2524 nds32_insertion_sort (void *base, size_t nmemb, size_t size,
2525 int (*compar) (const void *lhs, const void *rhs))
2526 {
2527 char *ptr = (char *) base;
2528 int i, j;
2529 char tmp[sizeof (Elf_Internal_Rela)];
2530
2531 BFD_ASSERT (size <= sizeof (tmp));
2532
2533 /* If i is less than j, i is inserted before j.
2534
2535 |---- j ----- i --------------|
2536 \ / \ /
2537 sorted unsorted
2538 */
2539
2540 for (i = 1; i < (int) nmemb; i++)
2541 {
2542 for (j = (i - 1); j >= 0; j--)
2543 if (compar (ptr + i * size, ptr + j * size) >= 0)
2544 break;
2545
2546 j++;
2547
2548 if (i == j)
2549 continue; /* i is in order. */
2550
2551 memcpy (tmp, ptr + i * size, size);
2552 memmove (ptr + (j + 1) * size, ptr + j * size, (i - j) * size);
2553 memcpy (ptr + j * size, tmp, size);
2554 }
2555 }
2556
2557 /* Sort relocation by r_offset.
2558
2559 We didn't use qsort () in stdlib, because quick-sort is not a stable sorting
2560 algorithm. Relocations at the same r_offset must keep their order.
2561 For example, RELAX_ENTRY must be the very first relocation entry.
2562
2563 Currently, this function implements insertion-sort.
2564
2565 FIXME: If we already sort them in assembler, why bother sort them
2566 here again? */
2567
2568 static int
2569 compar_reloc (const void *lhs, const void *rhs)
2570 {
2571 const Elf_Internal_Rela *l = (const Elf_Internal_Rela *) lhs;
2572 const Elf_Internal_Rela *r = (const Elf_Internal_Rela *) rhs;
2573
2574 if (l->r_offset > r->r_offset)
2575 return 1;
2576 else if (l->r_offset == r->r_offset)
2577 return 0;
2578 else
2579 return -1;
2580 }
2581
2582 /* Functions listed below are only used for old relocs.
2583 nds32_elf_9_pcrel_reloc
2584 nds32_elf_do_9_pcrel_reloc
2585 nds32_elf_hi20_reloc
2586 nds32_elf_relocate_hi20
2587 nds32_elf_lo12_reloc
2588 nds32_elf_sda15_reloc
2589 nds32_elf_generic_reloc. */
2590
2591 /* Handle the R_NDS32_9_PCREL & R_NDS32_9_PCREL_RELA reloc. */
2592
2593 static bfd_reloc_status_type
2594 nds32_elf_9_pcrel_reloc (bfd * abfd,
2595 arelent * reloc_entry,
2596 asymbol * symbol,
2597 void * data,
2598 asection * input_section,
2599 bfd * output_bfd,
2600 char ** error_message ATTRIBUTE_UNUSED)
2601 {
2602 /* This part is from bfd_elf_generic_reloc. */
2603 if (output_bfd != (bfd *) NULL
2604 && (symbol->flags & BSF_SECTION_SYM) == 0
2605 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2606 {
2607 reloc_entry->address += input_section->output_offset;
2608 return bfd_reloc_ok;
2609 }
2610
2611 if (output_bfd != NULL)
2612 {
2613 /* FIXME: See bfd_perform_relocation. Is this right? */
2614 return bfd_reloc_continue;
2615 }
2616
2617 return nds32_elf_do_9_pcrel_reloc (abfd, reloc_entry->howto,
2618 input_section,
2619 data, reloc_entry->address,
2620 symbol->section,
2621 (symbol->value
2622 + symbol->section->output_section->vma
2623 + symbol->section->output_offset),
2624 reloc_entry->addend);
2625 }
2626
2627 /* Utility to actually perform an R_NDS32_9_PCREL reloc. */
2628 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
2629
2630 static bfd_reloc_status_type
2631 nds32_elf_do_9_pcrel_reloc (bfd * abfd,
2632 reloc_howto_type * howto,
2633 asection * input_section,
2634 bfd_byte * data,
2635 bfd_vma offset,
2636 asection * symbol_section ATTRIBUTE_UNUSED,
2637 bfd_vma symbol_value,
2638 bfd_vma addend)
2639 {
2640 bfd_signed_vma relocation;
2641 unsigned short x;
2642 bfd_reloc_status_type status;
2643
2644 /* Sanity check the address (offset in section). */
2645 if (offset > bfd_get_section_limit (abfd, input_section))
2646 return bfd_reloc_outofrange;
2647
2648 relocation = symbol_value + addend;
2649 /* Make it pc relative. */
2650 relocation -= (input_section->output_section->vma
2651 + input_section->output_offset);
2652 /* These jumps mask off the lower two bits of the current address
2653 before doing pcrel calculations. */
2654 relocation -= (offset & -(bfd_vma) 2);
2655
2656 if (relocation < -ACCURATE_8BIT_S1 || relocation >= ACCURATE_8BIT_S1)
2657 status = bfd_reloc_overflow;
2658 else
2659 status = bfd_reloc_ok;
2660
2661 x = bfd_getb16 (data + offset);
2662
2663 relocation >>= howto->rightshift;
2664 relocation <<= howto->bitpos;
2665 x = (x & ~howto->dst_mask)
2666 | (((x & howto->src_mask) + relocation) & howto->dst_mask);
2667
2668 bfd_putb16 ((bfd_vma) x, data + offset);
2669
2670 return status;
2671 }
2672
2673 /* Handle the R_NDS32_HI20_[SU]LO relocs.
2674 HI20_SLO is for the add3 and load/store with displacement instructions.
2675 HI20 is for the or3 instruction.
2676 For R_NDS32_HI20_SLO, the lower 16 bits are sign extended when added to
2677 the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
2678 we must add one to the high 16 bytes (which will get subtracted off when
2679 the low 16 bits are added).
2680 These relocs have to be done in combination with an R_NDS32_LO12 reloc
2681 because there is a carry from the LO12 to the HI20. Here we just save
2682 the information we need; we do the actual relocation when we see the LO12.
2683 This code is copied from the elf32-mips.c. We also support an arbitrary
2684 number of HI20 relocs to be associated with a single LO12 reloc. The
2685 assembler sorts the relocs to ensure each HI20 immediately precedes its
2686 LO12. However if there are multiple copies, the assembler may not find
2687 the real LO12 so it picks the first one it finds. */
2688
2689 struct nds32_hi20
2690 {
2691 struct nds32_hi20 *next;
2692 bfd_byte *addr;
2693 bfd_vma addend;
2694 };
2695
2696 static struct nds32_hi20 *nds32_hi20_list;
2697
2698 static bfd_reloc_status_type
2699 nds32_elf_hi20_reloc (bfd *abfd ATTRIBUTE_UNUSED,
2700 arelent *reloc_entry,
2701 asymbol *symbol,
2702 void *data,
2703 asection *input_section,
2704 bfd *output_bfd,
2705 char **error_message ATTRIBUTE_UNUSED)
2706 {
2707 bfd_reloc_status_type ret;
2708 bfd_vma relocation;
2709 struct nds32_hi20 *n;
2710
2711 /* This part is from bfd_elf_generic_reloc.
2712 If we're relocating, and this an external symbol, we don't want
2713 to change anything. */
2714 if (output_bfd != (bfd *) NULL
2715 && (symbol->flags & BSF_SECTION_SYM) == 0 && reloc_entry->addend == 0)
2716 {
2717 reloc_entry->address += input_section->output_offset;
2718 return bfd_reloc_ok;
2719 }
2720
2721 /* Sanity check the address (offset in section). */
2722 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2723 return bfd_reloc_outofrange;
2724
2725 ret = bfd_reloc_ok;
2726 if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2727 ret = bfd_reloc_undefined;
2728
2729 if (bfd_is_com_section (symbol->section))
2730 relocation = 0;
2731 else
2732 relocation = symbol->value;
2733
2734 relocation += symbol->section->output_section->vma;
2735 relocation += symbol->section->output_offset;
2736 relocation += reloc_entry->addend;
2737
2738 /* Save the information, and let LO12 do the actual relocation. */
2739 n = (struct nds32_hi20 *) bfd_malloc ((bfd_size_type) sizeof *n);
2740 if (n == NULL)
2741 return bfd_reloc_outofrange;
2742
2743 n->addr = (bfd_byte *) data + reloc_entry->address;
2744 n->addend = relocation;
2745 n->next = nds32_hi20_list;
2746 nds32_hi20_list = n;
2747
2748 if (output_bfd != (bfd *) NULL)
2749 reloc_entry->address += input_section->output_offset;
2750
2751 return ret;
2752 }
2753
2754 /* Handle an NDS32 ELF HI20 reloc. */
2755
2756 static void
2757 nds32_elf_relocate_hi20 (bfd *input_bfd ATTRIBUTE_UNUSED,
2758 int type ATTRIBUTE_UNUSED,
2759 Elf_Internal_Rela *relhi,
2760 Elf_Internal_Rela *rello,
2761 bfd_byte *contents,
2762 bfd_vma addend)
2763 {
2764 unsigned long insn;
2765 bfd_vma addlo;
2766
2767 insn = bfd_getb32 (contents + relhi->r_offset);
2768
2769 addlo = bfd_getb32 (contents + rello->r_offset);
2770 addlo &= 0xfff;
2771
2772 addend += ((insn & 0xfffff) << 20) + addlo;
2773
2774 insn = (insn & 0xfff00000) | ((addend >> 12) & 0xfffff);
2775 bfd_putb32 (insn, contents + relhi->r_offset);
2776 }
2777
2778 /* Do an R_NDS32_LO12 relocation. This is a straightforward 12 bit
2779 inplace relocation; this function exists in order to do the
2780 R_NDS32_HI20_[SU]LO relocation described above. */
2781
2782 static bfd_reloc_status_type
2783 nds32_elf_lo12_reloc (bfd *input_bfd, arelent *reloc_entry, asymbol *symbol,
2784 void *data, asection *input_section, bfd *output_bfd,
2785 char **error_message)
2786 {
2787 /* This part is from bfd_elf_generic_reloc.
2788 If we're relocating, and this an external symbol, we don't want
2789 to change anything. */
2790 if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2791 && reloc_entry->addend == 0)
2792 {
2793 reloc_entry->address += input_section->output_offset;
2794 return bfd_reloc_ok;
2795 }
2796
2797 if (nds32_hi20_list != NULL)
2798 {
2799 struct nds32_hi20 *l;
2800
2801 l = nds32_hi20_list;
2802 while (l != NULL)
2803 {
2804 unsigned long insn;
2805 unsigned long val;
2806 unsigned long vallo;
2807 struct nds32_hi20 *next;
2808
2809 /* Do the HI20 relocation. Note that we actually don't need
2810 to know anything about the LO12 itself, except where to
2811 find the low 12 bits of the addend needed by the LO12. */
2812 insn = bfd_getb32 (l->addr);
2813 vallo = bfd_getb32 ((bfd_byte *) data + reloc_entry->address);
2814 vallo &= 0xfff;
2815 switch (reloc_entry->howto->type)
2816 {
2817 case R_NDS32_LO12S3:
2818 vallo <<= 3;
2819 break;
2820
2821 case R_NDS32_LO12S2:
2822 vallo <<= 2;
2823 break;
2824
2825 case R_NDS32_LO12S1:
2826 vallo <<= 1;
2827 break;
2828
2829 case R_NDS32_LO12S0:
2830 vallo <<= 0;
2831 break;
2832 }
2833
2834 val = ((insn & 0xfffff) << 12) + vallo;
2835 val += l->addend;
2836
2837 insn = (insn & ~(bfd_vma) 0xfffff) | ((val >> 12) & 0xfffff);
2838 bfd_putb32 ((bfd_vma) insn, l->addr);
2839
2840 next = l->next;
2841 free (l);
2842 l = next;
2843 }
2844
2845 nds32_hi20_list = NULL;
2846 }
2847
2848 /* Now do the LO12 reloc in the usual way.
2849 ??? It would be nice to call bfd_elf_generic_reloc here,
2850 but we have partial_inplace set. bfd_elf_generic_reloc will
2851 pass the handling back to bfd_install_relocation which will install
2852 a section relative addend which is wrong. */
2853 return nds32_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
2854 input_section, output_bfd, error_message);
2855 }
2856
2857 /* Do generic partial_inplace relocation.
2858 This is a local replacement for bfd_elf_generic_reloc. */
2859
2860 static bfd_reloc_status_type
2861 nds32_elf_generic_reloc (bfd *input_bfd, arelent *reloc_entry,
2862 asymbol *symbol, void *data, asection *input_section,
2863 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2864 {
2865 bfd_reloc_status_type ret;
2866 bfd_vma relocation;
2867 bfd_byte *inplace_address;
2868
2869 /* This part is from bfd_elf_generic_reloc.
2870 If we're relocating, and this an external symbol, we don't want
2871 to change anything. */
2872 if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2873 && reloc_entry->addend == 0)
2874 {
2875 reloc_entry->address += input_section->output_offset;
2876 return bfd_reloc_ok;
2877 }
2878
2879 /* Now do the reloc in the usual way.
2880 ??? It would be nice to call bfd_elf_generic_reloc here,
2881 but we have partial_inplace set. bfd_elf_generic_reloc will
2882 pass the handling back to bfd_install_relocation which will install
2883 a section relative addend which is wrong. */
2884
2885 /* Sanity check the address (offset in section). */
2886 if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section))
2887 return bfd_reloc_outofrange;
2888
2889 ret = bfd_reloc_ok;
2890 if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2891 ret = bfd_reloc_undefined;
2892
2893 if (bfd_is_com_section (symbol->section) || output_bfd != (bfd *) NULL)
2894 relocation = 0;
2895 else
2896 relocation = symbol->value;
2897
2898 /* Only do this for a final link. */
2899 if (output_bfd == (bfd *) NULL)
2900 {
2901 relocation += symbol->section->output_section->vma;
2902 relocation += symbol->section->output_offset;
2903 }
2904
2905 relocation += reloc_entry->addend;
2906 switch (reloc_entry->howto->type)
2907 {
2908 case R_NDS32_LO12S3:
2909 relocation >>= 3;
2910 break;
2911
2912 case R_NDS32_LO12S2:
2913 relocation >>= 2;
2914 break;
2915
2916 case R_NDS32_LO12S1:
2917 relocation >>= 1;
2918 break;
2919
2920 case R_NDS32_LO12S0:
2921 default:
2922 relocation >>= 0;
2923 break;
2924 }
2925
2926 inplace_address = (bfd_byte *) data + reloc_entry->address;
2927
2928 #define DOIT(x) \
2929 x = ((x & ~reloc_entry->howto->dst_mask) | \
2930 (((x & reloc_entry->howto->src_mask) + relocation) & \
2931 reloc_entry->howto->dst_mask))
2932
2933 switch (reloc_entry->howto->size)
2934 {
2935 case 1:
2936 {
2937 short x = bfd_getb16 (inplace_address);
2938
2939 DOIT (x);
2940 bfd_putb16 ((bfd_vma) x, inplace_address);
2941 }
2942 break;
2943 case 2:
2944 {
2945 unsigned long x = bfd_getb32 (inplace_address);
2946
2947 DOIT (x);
2948 bfd_putb32 ((bfd_vma) x, inplace_address);
2949 }
2950 break;
2951 default:
2952 BFD_ASSERT (0);
2953 }
2954
2955 if (output_bfd != (bfd *) NULL)
2956 reloc_entry->address += input_section->output_offset;
2957
2958 return ret;
2959 }
2960
2961 /* Handle the R_NDS32_SDA15 reloc.
2962 This reloc is used to compute the address of objects in the small data area
2963 and to perform loads and stores from that area.
2964 The lower 15 bits are sign extended and added to the register specified
2965 in the instruction, which is assumed to point to _SDA_BASE_.
2966
2967 Since the lower 15 bits offset is left-shifted 0, 1 or 2 bits depending on
2968 the access size, this must be taken care of. */
2969
2970 static bfd_reloc_status_type
2971 nds32_elf_sda15_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2972 asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2973 asection *input_section, bfd *output_bfd,
2974 char **error_message ATTRIBUTE_UNUSED)
2975 {
2976 /* This part is from bfd_elf_generic_reloc. */
2977 if (output_bfd != (bfd *) NULL
2978 && (symbol->flags & BSF_SECTION_SYM) == 0
2979 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2980 {
2981 reloc_entry->address += input_section->output_offset;
2982 return bfd_reloc_ok;
2983 }
2984
2985 if (output_bfd != NULL)
2986 {
2987 /* FIXME: See bfd_perform_relocation. Is this right? */
2988 return bfd_reloc_continue;
2989 }
2990
2991 /* FIXME: not sure what to do here yet. But then again, the linker
2992 may never call us. */
2993 abort ();
2994 }
2995
2996 /* nds32_elf_ignore_reloc is the special function for
2997 relocation types which don't need to be relocated
2998 like relaxation relocation types.
2999 This function simply return bfd_reloc_ok when it is
3000 invoked. */
3001
3002 static bfd_reloc_status_type
3003 nds32_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
3004 asymbol *symbol ATTRIBUTE_UNUSED,
3005 void *data ATTRIBUTE_UNUSED, asection *input_section,
3006 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
3007 {
3008 if (output_bfd != NULL)
3009 reloc_entry->address += input_section->output_offset;
3010
3011 return bfd_reloc_ok;
3012 }
3013 \f
3014
3015 /* Map BFD reloc types to NDS32 ELF reloc types. */
3016
3017 struct nds32_reloc_map_entry
3018 {
3019 bfd_reloc_code_real_type bfd_reloc_val;
3020 unsigned char elf_reloc_val;
3021 };
3022
3023 static const struct nds32_reloc_map_entry nds32_reloc_map[] =
3024 {
3025 {BFD_RELOC_NONE, R_NDS32_NONE},
3026 {BFD_RELOC_16, R_NDS32_16_RELA},
3027 {BFD_RELOC_32, R_NDS32_32_RELA},
3028 {BFD_RELOC_VTABLE_INHERIT, R_NDS32_RELA_GNU_VTINHERIT},
3029 {BFD_RELOC_VTABLE_ENTRY, R_NDS32_RELA_GNU_VTENTRY},
3030
3031 {BFD_RELOC_NDS32_20, R_NDS32_20_RELA},
3032 {BFD_RELOC_NDS32_9_PCREL, R_NDS32_9_PCREL_RELA},
3033 {BFD_RELOC_NDS32_WORD_9_PCREL, R_NDS32_WORD_9_PCREL_RELA},
3034 {BFD_RELOC_NDS32_15_PCREL, R_NDS32_15_PCREL_RELA},
3035 {BFD_RELOC_NDS32_17_PCREL, R_NDS32_17_PCREL_RELA},
3036 {BFD_RELOC_NDS32_25_PCREL, R_NDS32_25_PCREL_RELA},
3037 {BFD_RELOC_NDS32_HI20, R_NDS32_HI20_RELA},
3038 {BFD_RELOC_NDS32_LO12S3, R_NDS32_LO12S3_RELA},
3039 {BFD_RELOC_NDS32_LO12S2, R_NDS32_LO12S2_RELA},
3040 {BFD_RELOC_NDS32_LO12S1, R_NDS32_LO12S1_RELA},
3041 {BFD_RELOC_NDS32_LO12S0, R_NDS32_LO12S0_RELA},
3042 {BFD_RELOC_NDS32_LO12S0_ORI, R_NDS32_LO12S0_ORI_RELA},
3043 {BFD_RELOC_NDS32_SDA15S3, R_NDS32_SDA15S3_RELA},
3044 {BFD_RELOC_NDS32_SDA15S2, R_NDS32_SDA15S2_RELA},
3045 {BFD_RELOC_NDS32_SDA15S1, R_NDS32_SDA15S1_RELA},
3046 {BFD_RELOC_NDS32_SDA15S0, R_NDS32_SDA15S0_RELA},
3047 {BFD_RELOC_NDS32_SDA16S3, R_NDS32_SDA16S3_RELA},
3048 {BFD_RELOC_NDS32_SDA17S2, R_NDS32_SDA17S2_RELA},
3049 {BFD_RELOC_NDS32_SDA18S1, R_NDS32_SDA18S1_RELA},
3050 {BFD_RELOC_NDS32_SDA19S0, R_NDS32_SDA19S0_RELA},
3051 {BFD_RELOC_NDS32_GOT20, R_NDS32_GOT20},
3052 {BFD_RELOC_NDS32_9_PLTREL, R_NDS32_9_PLTREL},
3053 {BFD_RELOC_NDS32_25_PLTREL, R_NDS32_25_PLTREL},
3054 {BFD_RELOC_NDS32_COPY, R_NDS32_COPY},
3055 {BFD_RELOC_NDS32_GLOB_DAT, R_NDS32_GLOB_DAT},
3056 {BFD_RELOC_NDS32_JMP_SLOT, R_NDS32_JMP_SLOT},
3057 {BFD_RELOC_NDS32_RELATIVE, R_NDS32_RELATIVE},
3058 {BFD_RELOC_NDS32_GOTOFF, R_NDS32_GOTOFF},
3059 {BFD_RELOC_NDS32_GOTOFF_HI20, R_NDS32_GOTOFF_HI20},
3060 {BFD_RELOC_NDS32_GOTOFF_LO12, R_NDS32_GOTOFF_LO12},
3061 {BFD_RELOC_NDS32_GOTPC20, R_NDS32_GOTPC20},
3062 {BFD_RELOC_NDS32_GOT_HI20, R_NDS32_GOT_HI20},
3063 {BFD_RELOC_NDS32_GOT_LO12, R_NDS32_GOT_LO12},
3064 {BFD_RELOC_NDS32_GOTPC_HI20, R_NDS32_GOTPC_HI20},
3065 {BFD_RELOC_NDS32_GOTPC_LO12, R_NDS32_GOTPC_LO12},
3066 {BFD_RELOC_NDS32_INSN16, R_NDS32_INSN16},
3067 {BFD_RELOC_NDS32_LABEL, R_NDS32_LABEL},
3068 {BFD_RELOC_NDS32_LONGCALL1, R_NDS32_LONGCALL1},
3069 {BFD_RELOC_NDS32_LONGCALL2, R_NDS32_LONGCALL2},
3070 {BFD_RELOC_NDS32_LONGCALL3, R_NDS32_LONGCALL3},
3071 {BFD_RELOC_NDS32_LONGJUMP1, R_NDS32_LONGJUMP1},
3072 {BFD_RELOC_NDS32_LONGJUMP2, R_NDS32_LONGJUMP2},
3073 {BFD_RELOC_NDS32_LONGJUMP3, R_NDS32_LONGJUMP3},
3074 {BFD_RELOC_NDS32_LOADSTORE, R_NDS32_LOADSTORE},
3075 {BFD_RELOC_NDS32_9_FIXED, R_NDS32_9_FIXED_RELA},
3076 {BFD_RELOC_NDS32_15_FIXED, R_NDS32_15_FIXED_RELA},
3077 {BFD_RELOC_NDS32_17_FIXED, R_NDS32_17_FIXED_RELA},
3078 {BFD_RELOC_NDS32_25_FIXED, R_NDS32_25_FIXED_RELA},
3079 {BFD_RELOC_NDS32_LONGCALL4, R_NDS32_LONGCALL4},
3080 {BFD_RELOC_NDS32_LONGCALL5, R_NDS32_LONGCALL5},
3081 {BFD_RELOC_NDS32_LONGCALL6, R_NDS32_LONGCALL6},
3082 {BFD_RELOC_NDS32_LONGJUMP4, R_NDS32_LONGJUMP4},
3083 {BFD_RELOC_NDS32_LONGJUMP5, R_NDS32_LONGJUMP5},
3084 {BFD_RELOC_NDS32_LONGJUMP6, R_NDS32_LONGJUMP6},
3085 {BFD_RELOC_NDS32_LONGJUMP7, R_NDS32_LONGJUMP7},
3086 {BFD_RELOC_NDS32_PLTREL_HI20, R_NDS32_PLTREL_HI20},
3087 {BFD_RELOC_NDS32_PLTREL_LO12, R_NDS32_PLTREL_LO12},
3088 {BFD_RELOC_NDS32_PLT_GOTREL_HI20, R_NDS32_PLT_GOTREL_HI20},
3089 {BFD_RELOC_NDS32_PLT_GOTREL_LO12, R_NDS32_PLT_GOTREL_LO12},
3090 {BFD_RELOC_NDS32_SDA12S2_DP, R_NDS32_SDA12S2_DP_RELA},
3091 {BFD_RELOC_NDS32_SDA12S2_SP, R_NDS32_SDA12S2_SP_RELA},
3092 {BFD_RELOC_NDS32_LO12S2_DP, R_NDS32_LO12S2_DP_RELA},
3093 {BFD_RELOC_NDS32_LO12S2_SP, R_NDS32_LO12S2_SP_RELA},
3094 {BFD_RELOC_NDS32_DWARF2_OP1, R_NDS32_DWARF2_OP1_RELA},
3095 {BFD_RELOC_NDS32_DWARF2_OP2, R_NDS32_DWARF2_OP2_RELA},
3096 {BFD_RELOC_NDS32_DWARF2_LEB, R_NDS32_DWARF2_LEB_RELA},
3097 {BFD_RELOC_NDS32_UPDATE_TA, R_NDS32_UPDATE_TA_RELA},
3098 {BFD_RELOC_NDS32_PLT_GOTREL_LO20, R_NDS32_PLT_GOTREL_LO20},
3099 {BFD_RELOC_NDS32_PLT_GOTREL_LO15, R_NDS32_PLT_GOTREL_LO15},
3100 {BFD_RELOC_NDS32_PLT_GOTREL_LO19, R_NDS32_PLT_GOTREL_LO19},
3101 {BFD_RELOC_NDS32_GOT_LO15, R_NDS32_GOT_LO15},
3102 {BFD_RELOC_NDS32_GOT_LO19, R_NDS32_GOT_LO19},
3103 {BFD_RELOC_NDS32_GOTOFF_LO15, R_NDS32_GOTOFF_LO15},
3104 {BFD_RELOC_NDS32_GOTOFF_LO19, R_NDS32_GOTOFF_LO19},
3105 {BFD_RELOC_NDS32_GOT15S2, R_NDS32_GOT15S2_RELA},
3106 {BFD_RELOC_NDS32_GOT17S2, R_NDS32_GOT17S2_RELA},
3107 {BFD_RELOC_NDS32_5, R_NDS32_5_RELA},
3108 {BFD_RELOC_NDS32_10_UPCREL, R_NDS32_10_UPCREL_RELA},
3109 {BFD_RELOC_NDS32_SDA_FP7U2_RELA, R_NDS32_SDA_FP7U2_RELA},
3110 {BFD_RELOC_NDS32_RELAX_ENTRY, R_NDS32_RELAX_ENTRY},
3111 {BFD_RELOC_NDS32_GOT_SUFF, R_NDS32_GOT_SUFF},
3112 {BFD_RELOC_NDS32_GOTOFF_SUFF, R_NDS32_GOTOFF_SUFF},
3113 {BFD_RELOC_NDS32_PLT_GOT_SUFF, R_NDS32_PLT_GOT_SUFF},
3114 {BFD_RELOC_NDS32_MULCALL_SUFF, R_NDS32_MULCALL_SUFF},
3115 {BFD_RELOC_NDS32_PTR, R_NDS32_PTR},
3116 {BFD_RELOC_NDS32_PTR_COUNT, R_NDS32_PTR_COUNT},
3117 {BFD_RELOC_NDS32_PTR_RESOLVED, R_NDS32_PTR_RESOLVED},
3118 {BFD_RELOC_NDS32_PLTBLOCK, R_NDS32_PLTBLOCK},
3119 {BFD_RELOC_NDS32_RELAX_REGION_BEGIN, R_NDS32_RELAX_REGION_BEGIN},
3120 {BFD_RELOC_NDS32_RELAX_REGION_END, R_NDS32_RELAX_REGION_END},
3121 {BFD_RELOC_NDS32_MINUEND, R_NDS32_MINUEND},
3122 {BFD_RELOC_NDS32_SUBTRAHEND, R_NDS32_SUBTRAHEND},
3123 {BFD_RELOC_NDS32_DIFF8, R_NDS32_DIFF8},
3124 {BFD_RELOC_NDS32_DIFF16, R_NDS32_DIFF16},
3125 {BFD_RELOC_NDS32_DIFF32, R_NDS32_DIFF32},
3126 {BFD_RELOC_NDS32_DIFF_ULEB128, R_NDS32_DIFF_ULEB128},
3127 {BFD_RELOC_NDS32_EMPTY, R_NDS32_EMPTY},
3128 {BFD_RELOC_NDS32_25_ABS, R_NDS32_25_ABS_RELA},
3129 {BFD_RELOC_NDS32_DATA, R_NDS32_DATA},
3130 {BFD_RELOC_NDS32_TRAN, R_NDS32_TRAN},
3131 {BFD_RELOC_NDS32_17IFC_PCREL, R_NDS32_17IFC_PCREL_RELA},
3132 {BFD_RELOC_NDS32_10IFCU_PCREL, R_NDS32_10IFCU_PCREL_RELA},
3133 /* Not sure. */
3134 {BFD_RELOC_NDS32_TPOFF, R_NDS32_TLS_TPOFF},
3135 /* Missing: BFD_RELOC_NDS32_GOTTPOFF. */
3136 {BFD_RELOC_NDS32_TLS_LE_HI20, R_NDS32_TLS_LE_HI20},
3137 {BFD_RELOC_NDS32_TLS_LE_LO12, R_NDS32_TLS_LE_LO12},
3138 {BFD_RELOC_NDS32_TLS_LE_20, R_NDS32_TLS_LE_20},
3139 {BFD_RELOC_NDS32_TLS_LE_15S0, R_NDS32_TLS_LE_15S0},
3140 {BFD_RELOC_NDS32_TLS_LE_15S1, R_NDS32_TLS_LE_15S1},
3141 {BFD_RELOC_NDS32_TLS_LE_15S2, R_NDS32_TLS_LE_15S2},
3142 {BFD_RELOC_NDS32_TLS_LE_ADD, R_NDS32_TLS_LE_ADD},
3143 {BFD_RELOC_NDS32_TLS_LE_LS, R_NDS32_TLS_LE_LS},
3144 {BFD_RELOC_NDS32_TLS_IE_HI20, R_NDS32_TLS_IE_HI20},
3145 {BFD_RELOC_NDS32_TLS_IE_LO12, R_NDS32_TLS_IE_LO12},
3146 {BFD_RELOC_NDS32_TLS_IE_LO12S2, R_NDS32_TLS_IE_LO12S2},
3147 {BFD_RELOC_NDS32_TLS_IEGP_HI20, R_NDS32_TLS_IEGP_HI20},
3148 {BFD_RELOC_NDS32_TLS_IEGP_LO12, R_NDS32_TLS_IEGP_LO12},
3149 {BFD_RELOC_NDS32_TLS_IEGP_LO12S2, R_NDS32_TLS_IEGP_LO12S2},
3150 {BFD_RELOC_NDS32_TLS_IEGP_LW, R_NDS32_TLS_IEGP_LW},
3151 {BFD_RELOC_NDS32_TLS_DESC, R_NDS32_TLS_DESC},
3152 {BFD_RELOC_NDS32_TLS_DESC_HI20, R_NDS32_TLS_DESC_HI20},
3153 {BFD_RELOC_NDS32_TLS_DESC_LO12, R_NDS32_TLS_DESC_LO12},
3154 {BFD_RELOC_NDS32_TLS_DESC_20, R_NDS32_TLS_DESC_20},
3155 {BFD_RELOC_NDS32_TLS_DESC_SDA17S2, R_NDS32_TLS_DESC_SDA17S2},
3156 {BFD_RELOC_NDS32_TLS_DESC_ADD, R_NDS32_TLS_DESC_ADD},
3157 {BFD_RELOC_NDS32_TLS_DESC_FUNC, R_NDS32_TLS_DESC_FUNC},
3158 {BFD_RELOC_NDS32_TLS_DESC_CALL, R_NDS32_TLS_DESC_CALL},
3159 {BFD_RELOC_NDS32_TLS_DESC_MEM, R_NDS32_TLS_DESC_MEM},
3160 {BFD_RELOC_NDS32_REMOVE, R_NDS32_RELAX_REMOVE},
3161 {BFD_RELOC_NDS32_GROUP, R_NDS32_RELAX_GROUP},
3162 {BFD_RELOC_NDS32_LSI, R_NDS32_LSI},
3163 };
3164
3165 /* Patch tag. */
3166
3167 static reloc_howto_type *
3168 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
3169 const char *r_name)
3170 {
3171 unsigned int i;
3172
3173 for (i = 0; i < ARRAY_SIZE (nds32_elf_howto_table); i++)
3174 if (nds32_elf_howto_table[i].name != NULL
3175 && strcasecmp (nds32_elf_howto_table[i].name, r_name) == 0)
3176 return &nds32_elf_howto_table[i];
3177
3178 for (i = 0; i < ARRAY_SIZE (nds32_elf_relax_howto_table); i++)
3179 if (nds32_elf_relax_howto_table[i].name != NULL
3180 && strcasecmp (nds32_elf_relax_howto_table[i].name, r_name) == 0)
3181 return &nds32_elf_relax_howto_table[i];
3182
3183 return NULL;
3184 }
3185
3186 static reloc_howto_type *
3187 bfd_elf32_bfd_reloc_type_table_lookup (enum elf_nds32_reloc_type code)
3188 {
3189 if (code < R_NDS32_RELAX_ENTRY)
3190 {
3191 BFD_ASSERT (code < ARRAY_SIZE (nds32_elf_howto_table));
3192 return &nds32_elf_howto_table[code];
3193 }
3194 else
3195 {
3196 if ((size_t) (code - R_NDS32_RELAX_ENTRY)
3197 >= ARRAY_SIZE (nds32_elf_relax_howto_table))
3198 {
3199 int i = code;
3200 i += 1;
3201 }
3202
3203 BFD_ASSERT ((size_t) (code - R_NDS32_RELAX_ENTRY)
3204 < ARRAY_SIZE (nds32_elf_relax_howto_table));
3205 return &nds32_elf_relax_howto_table[code - R_NDS32_RELAX_ENTRY];
3206 }
3207 }
3208
3209 static reloc_howto_type *
3210 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
3211 bfd_reloc_code_real_type code)
3212 {
3213 unsigned int i;
3214
3215 for (i = 0; i < ARRAY_SIZE (nds32_reloc_map); i++)
3216 {
3217 if (nds32_reloc_map[i].bfd_reloc_val == code)
3218 return bfd_elf32_bfd_reloc_type_table_lookup
3219 (nds32_reloc_map[i].elf_reloc_val);
3220 }
3221
3222 return NULL;
3223 }
3224
3225 /* Set the howto pointer for an NDS32 ELF reloc. */
3226
3227 static bfd_boolean
3228 nds32_info_to_howto_rel (bfd *abfd, arelent *cache_ptr,
3229 Elf_Internal_Rela *dst)
3230 {
3231 enum elf_nds32_reloc_type r_type;
3232
3233 r_type = ELF32_R_TYPE (dst->r_info);
3234 if (r_type > R_NDS32_GNU_VTENTRY)
3235 {
3236 /* xgettext:c-format */
3237 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3238 abfd, r_type);
3239 bfd_set_error (bfd_error_bad_value);
3240 return FALSE;
3241 }
3242
3243 BFD_ASSERT (ELF32_R_TYPE (dst->r_info) <= R_NDS32_GNU_VTENTRY);
3244 cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
3245 return TRUE;
3246 }
3247
3248 static bfd_boolean
3249 nds32_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
3250 Elf_Internal_Rela *dst)
3251 {
3252 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
3253
3254 if ((r_type == R_NDS32_NONE)
3255 || ((r_type > R_NDS32_GNU_VTENTRY)
3256 && (r_type < R_NDS32_max)))
3257 {
3258 cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
3259 return TRUE;
3260 }
3261
3262 /* xgettext:c-format */
3263 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, r_type);
3264 bfd_set_error (bfd_error_bad_value);
3265 return FALSE;
3266 }
3267
3268 /* Support for core dump NOTE sections.
3269 Reference to include/linux/elfcore.h in Linux. */
3270
3271 static bfd_boolean
3272 nds32_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3273 {
3274 int offset;
3275 size_t size;
3276
3277 switch (note->descsz)
3278 {
3279 case 0x114:
3280 /* Linux/NDS32 32-bit, ABI1. */
3281
3282 /* pr_cursig */
3283 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3284
3285 /* pr_pid */
3286 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3287
3288 /* pr_reg */
3289 offset = 72;
3290 size = 200;
3291 break;
3292
3293 case 0xfc:
3294 /* Linux/NDS32 32-bit. */
3295
3296 /* pr_cursig */
3297 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3298
3299 /* pr_pid */
3300 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3301
3302 /* pr_reg */
3303 offset = 72;
3304 size = 176;
3305 break;
3306
3307 default:
3308 return FALSE;
3309 }
3310
3311 /* Make a ".reg" section. */
3312 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3313 size, note->descpos + offset);
3314 }
3315
3316 static bfd_boolean
3317 nds32_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3318 {
3319 switch (note->descsz)
3320 {
3321 case 124:
3322 /* Linux/NDS32. */
3323
3324 /* __kernel_uid_t, __kernel_gid_t are short on NDS32 platform. */
3325 elf_tdata (abfd)->core->program =
3326 _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
3327 elf_tdata (abfd)->core->command =
3328 _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
3329 break;
3330
3331 default:
3332 return FALSE;
3333 }
3334
3335 /* Note that for some reason, a spurious space is tacked
3336 onto the end of the args in some (at least one anyway)
3337 implementations, so strip it off if it exists. */
3338 {
3339 char *command = elf_tdata (abfd)->core->command;
3340 int n = strlen (command);
3341
3342 if (0 < n && command[n - 1] == ' ')
3343 command[n - 1] = '\0';
3344 }
3345
3346 return TRUE;
3347 }
3348
3349 /* Hook called by the linker routine which adds symbols from an object
3350 file. We must handle the special NDS32 section numbers here.
3351 We also keep watching for whether we need to create the sdata special
3352 linker sections. */
3353
3354 static bfd_boolean
3355 nds32_elf_add_symbol_hook (bfd *abfd,
3356 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3357 Elf_Internal_Sym *sym,
3358 const char **namep ATTRIBUTE_UNUSED,
3359 flagword *flagsp ATTRIBUTE_UNUSED,
3360 asection **secp, bfd_vma *valp)
3361 {
3362 switch (sym->st_shndx)
3363 {
3364 case SHN_COMMON:
3365 /* Common symbols less than the GP size are automatically
3366 treated as SHN_MIPS_SCOMMON symbols. */
3367 if (sym->st_size > elf_gp_size (abfd)
3368 || ELF_ST_TYPE (sym->st_info) == STT_TLS)
3369 break;
3370
3371 /* st_value is the alignemnt constraint.
3372 That might be its actual size if it is an array or structure. */
3373 switch (sym->st_value)
3374 {
3375 case 1:
3376 *secp = bfd_make_section_old_way (abfd, ".scommon_b");
3377 break;
3378 case 2:
3379 *secp = bfd_make_section_old_way (abfd, ".scommon_h");
3380 break;
3381 case 4:
3382 *secp = bfd_make_section_old_way (abfd, ".scommon_w");
3383 break;
3384 case 8:
3385 *secp = bfd_make_section_old_way (abfd, ".scommon_d");
3386 break;
3387 default:
3388 return TRUE;
3389 }
3390
3391 (*secp)->flags |= SEC_IS_COMMON;
3392 *valp = sym->st_size;
3393 break;
3394 }
3395
3396 return TRUE;
3397 }
3398
3399 /* This function can figure out the best location for a base register to access
3400 data relative to this base register
3401 INPUT:
3402 sda_d0: size of first DOUBLE WORD data section
3403 sda_w0: size of first WORD data section
3404 sda_h0: size of first HALF WORD data section
3405 sda_b : size of BYTE data section
3406 sda_hi: size of second HALF WORD data section
3407 sda_w1: size of second WORD data section
3408 sda_d1: size of second DOUBLE WORD data section
3409 OUTPUT:
3410 offset (always positive) from the beginning of sda_d0 if OK
3411 a negative error value if fail
3412 NOTE:
3413 these 7 sections have to be located back to back if exist
3414 a pass in 0 value for non-existing section */
3415
3416 /* Due to the interpretation of simm15 field of load/store depending on
3417 data accessing size, the organization of base register relative data shall
3418 like the following figure
3419 -------------------------------------------
3420 | DOUBLE WORD sized data (range +/- 128K)
3421 -------------------------------------------
3422 | WORD sized data (range +/- 64K)
3423 -------------------------------------------
3424 | HALF WORD sized data (range +/- 32K)
3425 -------------------------------------------
3426 | BYTE sized data (range +/- 16K)
3427 -------------------------------------------
3428 | HALF WORD sized data (range +/- 32K)
3429 -------------------------------------------
3430 | WORD sized data (range +/- 64K)
3431 -------------------------------------------
3432 | DOUBLE WORD sized data (range +/- 128K)
3433 -------------------------------------------
3434 Its base register shall be set to access these data freely. */
3435
3436 /* We have to figure out the SDA_BASE value, so that we can adjust the
3437 symbol value correctly. We look up the symbol _SDA_BASE_ in the output
3438 BFD. If we can't find it, we're stuck. We cache it in the ELF
3439 target data. We don't need to adjust the symbol value for an
3440 external symbol if we are producing relocatable output. */
3441
3442 static asection *sda_rela_sec = NULL;
3443
3444 #define SDA_SECTION_NUM 10
3445
3446 static bfd_reloc_status_type
3447 nds32_elf_final_sda_base (bfd * output_bfd,
3448 struct bfd_link_info * info,
3449 bfd_vma * psb,
3450 bfd_boolean add_symbol)
3451 {
3452 int relax_fp_as_gp;
3453 struct elf_nds32_link_hash_table *table;
3454 struct bfd_link_hash_entry *h, *h2;
3455 long unsigned int total = 0;
3456 asection *first = NULL, *final = NULL, *temp;
3457 bfd_vma sda_base = 0;
3458
3459 h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
3460 if (!h || (h->type != bfd_link_hash_defined
3461 && h->type != bfd_link_hash_defweak))
3462 {
3463 /* The first section must be 4-byte aligned to promise _SDA_BASE_ being
3464 4 byte-aligned. Therefore, it has to set the first section ".data"
3465 4 byte-aligned. */
3466 static const char sec_name[SDA_SECTION_NUM][10] =
3467 {
3468 ".data", ".got", ".sdata_d", ".sdata_w", ".sdata_h", ".sdata_b",
3469 ".sbss_b", ".sbss_h", ".sbss_w", ".sbss_d"
3470 };
3471 size_t i = 0;
3472
3473 if (output_bfd->sections == NULL)
3474 {
3475 *psb = elf_gp (output_bfd);
3476 return bfd_reloc_ok;
3477 }
3478
3479 /* Get the first and final section. */
3480 while (i < ARRAY_SIZE (sec_name))
3481 {
3482 temp = bfd_get_section_by_name (output_bfd, sec_name[i]);
3483 if (temp && !first && (temp->size != 0 || temp->rawsize != 0))
3484 first = temp;
3485 if (temp && (temp->size != 0 || temp->rawsize != 0))
3486 final = temp;
3487
3488 /* Summarize the sections in order to check if joining .bss. */
3489 if (temp && temp->size != 0)
3490 total += temp->size;
3491 else if (temp && temp->rawsize != 0)
3492 total += temp->rawsize;
3493
3494 i++;
3495 }
3496
3497 /* Check .bss size. */
3498 temp = bfd_get_section_by_name (output_bfd, ".bss");
3499 if (temp)
3500 {
3501 if (temp->size != 0)
3502 total += temp->size;
3503 else if (temp->rawsize != 0)
3504 total += temp->rawsize;
3505
3506 if (total < 0x80000)
3507 {
3508 if (!first && (temp->size != 0 || temp->rawsize != 0))
3509 first = temp;
3510 if ((temp->size != 0 || temp->rawsize != 0))
3511 final = temp;
3512 }
3513 }
3514
3515 if (first && final)
3516 {
3517 /* The middle of data region. */
3518 sda_base = final->vma / 2 + final->rawsize / 2 + first->vma / 2;
3519
3520 /* Find the section sda_base located. */
3521 i = 0;
3522 while (i < ARRAY_SIZE (sec_name))
3523 {
3524 final = bfd_get_section_by_name (output_bfd, sec_name[i]);
3525 if (final && (final->size != 0 || final->rawsize != 0)
3526 && sda_base >= final->vma)
3527 {
3528 first = final;
3529 i++;
3530 }
3531 else
3532 break;
3533 }
3534 }
3535 else
3536 {
3537 /* If there is not any default data section in output bfd, try to find
3538 the first data section. If no data section be found, just simplily
3539 choose the first output section. */
3540 temp = output_bfd->sections;
3541 while (temp)
3542 {
3543 if (temp->flags & SEC_ALLOC
3544 && (((temp->flags & SEC_DATA)
3545 && ((temp->flags & SEC_READONLY) == 0))
3546 || (temp->flags & SEC_LOAD) == 0)
3547 && (temp->size != 0 || temp->rawsize != 0))
3548 {
3549 if (!first)
3550 first = temp;
3551 final = temp;
3552 }
3553 temp = temp->next;
3554 }
3555
3556 /* There is no data or bss section. */
3557 if (!first || (first->size == 0 && first->rawsize == 0))
3558 {
3559 first = output_bfd->sections;
3560 while (first && first->size == 0 && first->rawsize == 0)
3561 first = first->next;
3562 }
3563
3564 /* There is no concrete section. */
3565 if (!first)
3566 {
3567 *psb = elf_gp (output_bfd);
3568 return bfd_reloc_ok;
3569 }
3570
3571 if (final && (final->vma + final->rawsize - first->vma) <= 0x4000)
3572 sda_base = final->vma / 2 + final->rawsize / 2 + first->vma / 2;
3573 else
3574 sda_base = first->vma + 0x2000;
3575 }
3576
3577 sda_base -= first->vma;
3578 sda_base = sda_base & (~7);
3579
3580 if (!_bfd_generic_link_add_one_symbol
3581 (info, output_bfd, "_SDA_BASE_", BSF_GLOBAL | BSF_WEAK, first,
3582 (bfd_vma) sda_base, (const char *) NULL, FALSE,
3583 get_elf_backend_data (output_bfd)->collect, &h))
3584 return FALSE;
3585
3586 sda_rela_sec = first;
3587 }
3588
3589 /* Set _FP_BASE_ to _SDA_BASE_. */
3590 table = nds32_elf_hash_table (info);
3591 relax_fp_as_gp = table->relax_fp_as_gp;
3592 h2 = bfd_link_hash_lookup (info->hash, FP_BASE_NAME, FALSE, FALSE, FALSE);
3593 /* _SDA_BASE_ is difined in linker script. */
3594 if (!first)
3595 {
3596 first = h->u.def.section;
3597 sda_base = h->u.def.value;
3598 }
3599
3600 if (relax_fp_as_gp && h2
3601 && (h2->type == bfd_link_hash_undefweak
3602 || h2->type == bfd_link_hash_undefined))
3603 {
3604 /* Define a weak FP_BASE_NAME here to prevent the undefined symbol.
3605 And set FP equal to SDA_BASE to do relaxation for
3606 la $fp, _FP_BASE_. */
3607 if (!_bfd_generic_link_add_one_symbol
3608 (info, output_bfd, FP_BASE_NAME, BSF_GLOBAL | BSF_WEAK,
3609 first, sda_base, (const char *) NULL,
3610 FALSE, get_elf_backend_data (output_bfd)->collect, &h2))
3611 return FALSE;
3612 }
3613
3614 if (add_symbol)
3615 {
3616 if (h)
3617 {
3618 /* Now set gp. */
3619 elf_gp (output_bfd) = (h->u.def.value
3620 + h->u.def.section->output_section->vma
3621 + h->u.def.section->output_offset);
3622 }
3623 else
3624 {
3625 _bfd_error_handler (_("error: can't find symbol: %s"), "_SDA_BASE_");
3626 return bfd_reloc_dangerous;
3627 }
3628 }
3629
3630 *psb = h->u.def.value
3631 + h->u.def.section->output_section->vma
3632 + h->u.def.section->output_offset;
3633 return bfd_reloc_ok;
3634 }
3635 \f
3636
3637 /* Return size of a PLT entry. */
3638 #define elf_nds32_sizeof_plt(info) PLT_ENTRY_SIZE
3639
3640 /* Create an entry in an nds32 ELF linker hash table. */
3641
3642 static struct bfd_hash_entry *
3643 nds32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
3644 struct bfd_hash_table *table,
3645 const char *string)
3646 {
3647 struct elf_nds32_link_hash_entry *ret;
3648
3649 ret = (struct elf_nds32_link_hash_entry *) entry;
3650
3651 /* Allocate the structure if it has not already been allocated by a
3652 subclass. */
3653 if (ret == NULL)
3654 ret = (struct elf_nds32_link_hash_entry *)
3655 bfd_hash_allocate (table, sizeof (struct elf_nds32_link_hash_entry));
3656
3657 if (ret == NULL)
3658 return (struct bfd_hash_entry *) ret;
3659
3660 /* Call the allocation method of the superclass. */
3661 ret = (struct elf_nds32_link_hash_entry *)
3662 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);
3663
3664 if (ret != NULL)
3665 {
3666 struct elf_nds32_link_hash_entry *eh;
3667
3668 eh = (struct elf_nds32_link_hash_entry *) ret;
3669 eh->tls_type = GOT_UNKNOWN;
3670 eh->offset_to_gp = 0;
3671 }
3672
3673 return (struct bfd_hash_entry *) ret;
3674 }
3675
3676 /* Create an nds32 ELF linker hash table. */
3677
3678 static struct bfd_link_hash_table *
3679 nds32_elf_link_hash_table_create (bfd *abfd)
3680 {
3681 struct elf_nds32_link_hash_table *ret;
3682
3683 size_t amt = sizeof (struct elf_nds32_link_hash_table);
3684
3685 ret = (struct elf_nds32_link_hash_table *) bfd_zmalloc (amt);
3686 if (ret == NULL)
3687 return NULL;
3688
3689 /* Patch tag. */
3690 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3691 nds32_elf_link_hash_newfunc,
3692 sizeof (struct elf_nds32_link_hash_entry),
3693 NDS32_ELF_DATA))
3694 {
3695 free (ret);
3696 return NULL;
3697 }
3698
3699 ret->sdynbss = NULL;
3700 ret->srelbss = NULL;
3701 ret->sym_ld_script = NULL;
3702
3703 return &ret->root.root;
3704 }
3705
3706 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
3707 shortcuts to them in our hash table. */
3708
3709 static bfd_boolean
3710 create_got_section (bfd *dynobj, struct bfd_link_info *info)
3711 {
3712 struct elf_link_hash_table *ehtab;
3713
3714 if (!_bfd_elf_create_got_section (dynobj, info))
3715 return FALSE;
3716
3717 ehtab = elf_hash_table (info);
3718 ehtab->sgot = bfd_get_section_by_name (dynobj, ".got");
3719 ehtab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
3720 if (!ehtab->sgot || !ehtab->sgotplt)
3721 abort ();
3722
3723 /* _bfd_elf_create_got_section will create it for us. */
3724 ehtab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3725 if (ehtab->srelgot == NULL
3726 || !bfd_set_section_flags (ehtab->srelgot,
3727 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
3728 | SEC_IN_MEMORY | SEC_LINKER_CREATED
3729 | SEC_READONLY))
3730 || !bfd_set_section_alignment (ehtab->srelgot, 2))
3731 return FALSE;
3732
3733 return TRUE;
3734 }
3735
3736 /* Create dynamic sections when linking against a dynamic object. */
3737
3738 static bfd_boolean
3739 nds32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3740 {
3741 struct elf_link_hash_table *ehtab;
3742 struct elf_nds32_link_hash_table *htab;
3743 flagword flags, pltflags;
3744 register asection *s;
3745 const struct elf_backend_data *bed;
3746 int ptralign = 2; /* 32-bit */
3747 const char *secname;
3748 char *relname;
3749 flagword secflags;
3750 asection *sec;
3751
3752 bed = get_elf_backend_data (abfd);
3753 ehtab = elf_hash_table (info);
3754 htab = nds32_elf_hash_table (info);
3755
3756 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3757 .rel[a].bss sections. */
3758
3759 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3760 | SEC_LINKER_CREATED);
3761
3762 pltflags = flags;
3763 pltflags |= SEC_CODE;
3764 if (bed->plt_not_loaded)
3765 pltflags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
3766 if (bed->plt_readonly)
3767 pltflags |= SEC_READONLY;
3768
3769 s = bfd_make_section (abfd, ".plt");
3770 ehtab->splt = s;
3771 if (s == NULL
3772 || !bfd_set_section_flags (s, pltflags)
3773 || !bfd_set_section_alignment (s, bed->plt_alignment))
3774 return FALSE;
3775
3776 if (bed->want_plt_sym)
3777 {
3778 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3779 .plt section. */
3780 struct bfd_link_hash_entry *bh = NULL;
3781 struct elf_link_hash_entry *h;
3782
3783 if (!(_bfd_generic_link_add_one_symbol
3784 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3785 (bfd_vma) 0, (const char *) NULL, FALSE,
3786 get_elf_backend_data (abfd)->collect, &bh)))
3787 return FALSE;
3788
3789 h = (struct elf_link_hash_entry *) bh;
3790 h->def_regular = 1;
3791 h->type = STT_OBJECT;
3792
3793 if (bfd_link_pic (info) && !bfd_elf_link_record_dynamic_symbol (info, h))
3794 return FALSE;
3795 }
3796
3797 s = bfd_make_section (abfd,
3798 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
3799 ehtab->srelplt = s;
3800 if (s == NULL
3801 || !bfd_set_section_flags (s, flags | SEC_READONLY)
3802 || !bfd_set_section_alignment (s, ptralign))
3803 return FALSE;
3804
3805 if (ehtab->sgot == NULL && !create_got_section (abfd, info))
3806 return FALSE;
3807
3808 for (sec = abfd->sections; sec; sec = sec->next)
3809 {
3810 secflags = bfd_section_flags (sec);
3811 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3812 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3813 continue;
3814 secname = bfd_section_name (sec);
3815 relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
3816 strcpy (relname, ".rela");
3817 strcat (relname, secname);
3818 if (bfd_get_section_by_name (abfd, secname))
3819 continue;
3820 s = bfd_make_section (abfd, relname);
3821 if (s == NULL
3822 || !bfd_set_section_flags (s, flags | SEC_READONLY)
3823 || !bfd_set_section_alignment (s, ptralign))
3824 return FALSE;
3825 }
3826
3827 if (bed->want_dynbss)
3828 {
3829 /* The .dynbss section is a place to put symbols which are defined
3830 by dynamic objects, are referenced by regular objects, and are
3831 not functions. We must allocate space for them in the process
3832 image and use a R_*_COPY reloc to tell the dynamic linker to
3833 initialize them at run time. The linker script puts the .dynbss
3834 section into the .bss section of the final image. */
3835 s = bfd_make_section (abfd, ".dynbss");
3836 htab->sdynbss = s;
3837 if (s == NULL
3838 || !bfd_set_section_flags (s, SEC_ALLOC | SEC_LINKER_CREATED))
3839 return FALSE;
3840 /* The .rel[a].bss section holds copy relocs. This section is not
3841 normally needed. We need to create it here, though, so that the
3842 linker will map it to an output section. We can't just create it
3843 only if we need it, because we will not know whether we need it
3844 until we have seen all the input files, and the first time the
3845 main linker code calls BFD after examining all the input files
3846 (size_dynamic_sections) the input sections have already been
3847 mapped to the output sections. If the section turns out not to
3848 be needed, we can discard it later. We will never need this
3849 section when generating a shared object, since they do not use
3850 copy relocs. */
3851 if (!bfd_link_pic (info))
3852 {
3853 s = bfd_make_section (abfd, (bed->default_use_rela_p
3854 ? ".rela.bss" : ".rel.bss"));
3855 htab->srelbss = s;
3856 if (s == NULL
3857 || !bfd_set_section_flags (s, flags | SEC_READONLY)
3858 || !bfd_set_section_alignment (s, ptralign))
3859 return FALSE;
3860 }
3861 }
3862
3863 return TRUE;
3864 }
3865
3866 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3867 static void
3868 nds32_elf_copy_indirect_symbol (struct bfd_link_info *info,
3869 struct elf_link_hash_entry *dir,
3870 struct elf_link_hash_entry *ind)
3871 {
3872 struct elf_nds32_link_hash_entry *edir, *eind;
3873
3874 edir = (struct elf_nds32_link_hash_entry *) dir;
3875 eind = (struct elf_nds32_link_hash_entry *) ind;
3876
3877 if (ind->root.type == bfd_link_hash_indirect)
3878 {
3879 if (dir->got.refcount <= 0)
3880 {
3881 edir->tls_type = eind->tls_type;
3882 eind->tls_type = GOT_UNKNOWN;
3883 }
3884 }
3885
3886 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3887 }
3888 \f
3889 /* Adjust a symbol defined by a dynamic object and referenced by a
3890 regular object. The current definition is in some section of the
3891 dynamic object, but we're not including those sections. We have to
3892 change the definition to something the rest of the link can
3893 understand. */
3894
3895 static bfd_boolean
3896 nds32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
3897 struct elf_link_hash_entry *h)
3898 {
3899 struct elf_nds32_link_hash_table *htab;
3900 bfd *dynobj;
3901 asection *s;
3902 unsigned int power_of_two;
3903
3904 dynobj = elf_hash_table (info)->dynobj;
3905
3906 /* Make sure we know what is going on here. */
3907 BFD_ASSERT (dynobj != NULL
3908 && (h->needs_plt
3909 || h->is_weakalias
3910 || (h->def_dynamic && h->ref_regular && !h->def_regular)));
3911
3912
3913 /* If this is a function, put it in the procedure linkage table. We
3914 will fill in the contents of the procedure linkage table later,
3915 when we know the address of the .got section. */
3916 if (h->type == STT_FUNC || h->needs_plt)
3917 {
3918 if (!bfd_link_pic (info)
3919 && !h->def_dynamic
3920 && !h->ref_dynamic
3921 && h->root.type != bfd_link_hash_undefweak
3922 && h->root.type != bfd_link_hash_undefined)
3923 {
3924 /* This case can occur if we saw a PLT reloc in an input
3925 file, but the symbol was never referred to by a dynamic
3926 object. In such a case, we don't actually need to build
3927 a procedure linkage table, and we can just do a PCREL
3928 reloc instead. */
3929 h->plt.offset = (bfd_vma) - 1;
3930 h->needs_plt = 0;
3931 }
3932
3933 return TRUE;
3934 }
3935 else
3936 h->plt.offset = (bfd_vma) - 1;
3937
3938 /* If this is a weak symbol, and there is a real definition, the
3939 processor independent code will have arranged for us to see the
3940 real definition first, and we can just use the same value. */
3941 if (h->is_weakalias)
3942 {
3943 struct elf_link_hash_entry *def = weakdef (h);
3944 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
3945 h->root.u.def.section = def->root.u.def.section;
3946 h->root.u.def.value = def->root.u.def.value;
3947 return TRUE;
3948 }
3949
3950 /* This is a reference to a symbol defined by a dynamic object which
3951 is not a function. */
3952
3953 /* If we are creating a shared library, we must presume that the
3954 only references to the symbol are via the global offset table.
3955 For such cases we need not do anything here; the relocations will
3956 be handled correctly by relocate_section. */
3957 if (bfd_link_pic (info))
3958 return TRUE;
3959
3960 /* If there are no references to this symbol that do not use the
3961 GOT, we don't need to generate a copy reloc. */
3962 if (!h->non_got_ref)
3963 return TRUE;
3964
3965 /* If -z nocopyreloc was given, we won't generate them either. */
3966 if (0 && info->nocopyreloc)
3967 {
3968 h->non_got_ref = 0;
3969 return TRUE;
3970 }
3971
3972 /* If we don't find any dynamic relocs in read-only sections, then
3973 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
3974 if (!_bfd_elf_readonly_dynrelocs (h))
3975 {
3976 h->non_got_ref = 0;
3977 return TRUE;
3978 }
3979
3980 /* We must allocate the symbol in our .dynbss section, which will
3981 become part of the .bss section of the executable. There will be
3982 an entry for this symbol in the .dynsym section. The dynamic
3983 object will contain position independent code, so all references
3984 from the dynamic object to this symbol will go through the global
3985 offset table. The dynamic linker will use the .dynsym entry to
3986 determine the address it must put in the global offset table, so
3987 both the dynamic object and the regular object will refer to the
3988 same memory location for the variable. */
3989
3990 htab = nds32_elf_hash_table (info);
3991 s = htab->sdynbss;
3992 BFD_ASSERT (s != NULL);
3993
3994 /* We must generate a R_NDS32_COPY reloc to tell the dynamic linker
3995 to copy the initial value out of the dynamic object and into the
3996 runtime process image. We need to remember the offset into the
3997 .rela.bss section we are going to use. */
3998 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3999 {
4000 asection *srel;
4001
4002 srel = htab->srelbss;
4003 BFD_ASSERT (srel != NULL);
4004 srel->size += sizeof (Elf32_External_Rela);
4005 h->needs_copy = 1;
4006 }
4007
4008 /* We need to figure out the alignment required for this symbol. I
4009 have no idea how ELF linkers handle this. */
4010 power_of_two = bfd_log2 (h->size);
4011 if (power_of_two > 3)
4012 power_of_two = 3;
4013
4014 /* Apply the required alignment. */
4015 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
4016 if (power_of_two > bfd_section_alignment (s))
4017 {
4018 if (!bfd_set_section_alignment (s, power_of_two))
4019 return FALSE;
4020 }
4021
4022 /* Define the symbol as being at this point in the section. */
4023 h->root.u.def.section = s;
4024 h->root.u.def.value = s->size;
4025
4026 /* Increment the section size to make room for the symbol. */
4027 s->size += h->size;
4028
4029 return TRUE;
4030 }
4031
4032 /* Allocate space in .plt, .got and associated reloc sections for
4033 dynamic relocs. */
4034
4035 static bfd_boolean
4036 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
4037 {
4038 struct bfd_link_info *info;
4039 struct elf_link_hash_table *ehtab;
4040 struct elf_nds32_link_hash_table *htab;
4041 struct elf_dyn_relocs *p;
4042
4043 if (h->root.type == bfd_link_hash_indirect)
4044 return TRUE;
4045
4046 /* When warning symbols are created, they **replace** the "real"
4047 entry in the hash table, thus we never get to see the real
4048 symbol in a hash traversal. So look at it now. */
4049 if (h->root.type == bfd_link_hash_warning)
4050 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4051
4052 info = (struct bfd_link_info *) inf;
4053 ehtab = elf_hash_table (info);
4054 htab = nds32_elf_hash_table (info);
4055 if (htab == NULL)
4056 return FALSE;
4057
4058 if ((htab->root.dynamic_sections_created || h->type == STT_GNU_IFUNC)
4059 && h->plt.refcount > 0
4060 && !(bfd_link_pie (info) && h->def_regular))
4061 {
4062 /* Make sure this symbol is output as a dynamic symbol.
4063 Undefined weak syms won't yet be marked as dynamic. */
4064 if (h->dynindx == -1 && !h->forced_local)
4065 {
4066 if (!bfd_elf_link_record_dynamic_symbol (info, h))
4067 return FALSE;
4068 }
4069
4070 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
4071 {
4072 asection *s = ehtab->splt;
4073
4074 /* If this is the first .plt entry, make room for the special
4075 first entry. */
4076 if (s->size == 0)
4077 s->size += PLT_ENTRY_SIZE;
4078
4079 h->plt.offset = s->size;
4080
4081 /* If this symbol is not defined in a regular file, and we are
4082 not generating a shared library, then set the symbol to this
4083 location in the .plt. This is required to make function
4084 pointers compare as equal between the normal executable and
4085 the shared library. */
4086 if (!bfd_link_pic (info) && !h->def_regular)
4087 {
4088 h->root.u.def.section = s;
4089 h->root.u.def.value = h->plt.offset;
4090 }
4091
4092 /* Make room for this entry. */
4093 s->size += PLT_ENTRY_SIZE;
4094
4095 /* We also need to make an entry in the .got.plt section, which
4096 will be placed in the .got section by the linker script. */
4097 ehtab->sgotplt->size += 4;
4098
4099 /* We also need to make an entry in the .rel.plt section. */
4100 ehtab->srelplt->size += sizeof (Elf32_External_Rela);
4101 if (htab->tls_desc_trampoline)
4102 htab->next_tls_desc_index++;
4103 }
4104 else
4105 {
4106 h->plt.offset = (bfd_vma) - 1;
4107 h->needs_plt = 0;
4108 }
4109 }
4110 else
4111 {
4112 h->plt.offset = (bfd_vma) - 1;
4113 h->needs_plt = 0;
4114 }
4115
4116 if (h->got.refcount > 0)
4117 {
4118 asection *sgot;
4119 bfd_boolean dyn;
4120 int tls_type = elf32_nds32_hash_entry (h)->tls_type;
4121
4122 /* Make sure this symbol is output as a dynamic symbol.
4123 Undefined weak syms won't yet be marked as dynamic. */
4124 if (h->dynindx == -1 && !h->forced_local)
4125 {
4126 if (!bfd_elf_link_record_dynamic_symbol (info, h))
4127 return FALSE;
4128 }
4129
4130 sgot = elf_hash_table (info)->sgot;
4131 h->got.offset = sgot->size;
4132
4133 if (tls_type == GOT_UNKNOWN)
4134 abort ();
4135
4136 /* Non-TLS symbols, and TLS_IE need one GOT slot. */
4137 if (tls_type & (GOT_NORMAL | GOT_TLS_IE | GOT_TLS_IEGP))
4138 sgot->size += 4;
4139 else
4140 {
4141 /* TLS_DESC, TLS_GD, and TLS_LD need 2 consecutive GOT slots. */
4142 if (tls_type & GOT_TLS_DESC)
4143 sgot->size += 8;
4144 }
4145
4146 dyn = htab->root.dynamic_sections_created;
4147
4148 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
4149 {
4150 if (tls_type == GOT_TLS_DESC && htab->tls_desc_trampoline)
4151 {
4152 /* TLS_DESC with trampoline needs a relocation slot
4153 within .rela.plt. */
4154 htab->num_tls_desc++;
4155 ehtab->srelplt->size += sizeof (Elf32_External_Rela);
4156 htab->tls_trampoline = -1;
4157 }
4158 else
4159 {
4160 /* other relocations, including TLS_DESC without trampoline, need
4161 a relocation slot within .rela.got. */
4162 ehtab->srelgot->size += sizeof (Elf32_External_Rela);
4163 }
4164 }
4165 }
4166 else
4167 h->got.offset = (bfd_vma)-1;
4168
4169 if (h->dyn_relocs == NULL)
4170 return TRUE;
4171
4172 /* In the shared -Bsymbolic case, discard space allocated for
4173 dynamic pc-relative relocs against symbols which turn out to be
4174 defined in regular objects. For the normal shared case, discard
4175 space for pc-relative relocs that have become local due to symbol
4176 visibility changes. */
4177
4178 if (bfd_link_pic (info))
4179 {
4180 if (h->def_regular && (h->forced_local || info->symbolic))
4181 {
4182 struct elf_dyn_relocs **pp;
4183
4184 for (pp = &h->dyn_relocs; (p = *pp) != NULL;)
4185 {
4186 p->count -= p->pc_count;
4187 p->pc_count = 0;
4188 if (p->count == 0)
4189 *pp = p->next;
4190 else
4191 pp = &p->next;
4192 }
4193 }
4194 }
4195 else
4196 {
4197 /* For the non-shared case, discard space for relocs against
4198 symbols which turn out to need copy relocs or are not dynamic. */
4199
4200 if (!h->non_got_ref
4201 && ((h->def_dynamic
4202 && !h->def_regular)
4203 || (htab->root.dynamic_sections_created
4204 && (h->root.type == bfd_link_hash_undefweak
4205 || h->root.type == bfd_link_hash_undefined))))
4206 {
4207 /* Make sure this symbol is output as a dynamic symbol.
4208 Undefined weak syms won't yet be marked as dynamic. */
4209 if (h->dynindx == -1 && !h->forced_local)
4210 {
4211 if (!bfd_elf_link_record_dynamic_symbol (info, h))
4212 return FALSE;
4213 }
4214
4215 /* If that succeeded, we know we'll be keeping all the
4216 relocs. */
4217 if (h->dynindx != -1)
4218 goto keep;
4219 }
4220
4221 h->dyn_relocs = NULL;
4222
4223 keep:;
4224 }
4225
4226 /* Finally, allocate space. */
4227 for (p = h->dyn_relocs; p != NULL; p = p->next)
4228 {
4229 asection *sreloc = elf_section_data (p->sec)->sreloc;
4230 sreloc->size += p->count * sizeof (Elf32_External_Rela);
4231 }
4232
4233 return TRUE;
4234 }
4235
4236 /* Add relocation REL to the end of relocation section SRELOC. */
4237
4238 static void
4239 elf32_nds32_add_dynreloc (bfd *output_bfd,
4240 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4241 asection *sreloc, Elf_Internal_Rela *rel)
4242 {
4243 bfd_byte *loc;
4244 if (sreloc == NULL)
4245 abort ();
4246
4247 loc = sreloc->contents;
4248 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4249 if (sreloc->reloc_count * sizeof (Elf32_External_Rela) > sreloc->size)
4250 abort ();
4251
4252 bfd_elf32_swap_reloca_out (output_bfd, rel, loc);
4253 }
4254
4255 /* Set the sizes of the dynamic sections. */
4256
4257 static bfd_boolean
4258 nds32_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
4259 struct bfd_link_info *info)
4260 {
4261 struct elf_nds32_link_hash_table *htab;
4262 bfd *dynobj;
4263 asection *s;
4264 bfd_boolean relocs;
4265 bfd_boolean plt;
4266 bfd *ibfd;
4267
4268 htab = nds32_elf_hash_table (info);
4269 if (htab == NULL)
4270 return FALSE;
4271
4272 dynobj = elf_hash_table (info)->dynobj;
4273 BFD_ASSERT (dynobj != NULL);
4274
4275 if (elf_hash_table (info)->dynamic_sections_created)
4276 {
4277 /* Set the contents of the .interp section to the interpreter. */
4278 if (bfd_link_executable (info) && !info->nointerp)
4279 {
4280 s = bfd_get_section_by_name (dynobj, ".interp");
4281 BFD_ASSERT (s != NULL);
4282 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
4283 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4284 }
4285 }
4286
4287 /* Set up .got offsets for local syms, and space for local dynamic
4288 relocs. */
4289 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
4290 {
4291 bfd_signed_vma *local_got;
4292 bfd_signed_vma *end_local_got;
4293 bfd_size_type locsymcount;
4294 Elf_Internal_Shdr *symtab_hdr;
4295 asection *sgot;
4296 char *local_tls_type;
4297 unsigned long symndx;
4298 bfd_vma *local_tlsdesc_gotent;
4299
4300 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
4301 continue;
4302
4303 for (s = ibfd->sections; s != NULL; s = s->next)
4304 {
4305 struct elf_dyn_relocs *p;
4306
4307 for (p = ((struct elf_dyn_relocs *)
4308 elf_section_data (s)->local_dynrel);
4309 p != NULL; p = p->next)
4310 {
4311 if (!bfd_is_abs_section (p->sec)
4312 && bfd_is_abs_section (p->sec->output_section))
4313 {
4314 /* Input section has been discarded, either because
4315 it is a copy of a linkonce section or due to
4316 linker script /DISCARD/, so we'll be discarding
4317 the relocs too. */
4318 }
4319 else if (p->count != 0)
4320 {
4321 asection *sreloc = elf_section_data (p->sec)->sreloc;
4322 sreloc->size += p->count * sizeof (Elf32_External_Rela);
4323 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
4324 info->flags |= DF_TEXTREL;
4325 }
4326 }
4327 }
4328
4329 local_got = elf_local_got_refcounts (ibfd);
4330 if (!local_got)
4331 continue;
4332
4333 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4334 locsymcount = symtab_hdr->sh_info;
4335 end_local_got = local_got + locsymcount;
4336 sgot = elf_hash_table (info)->sgot;
4337 local_tls_type = elf32_nds32_local_got_tls_type (ibfd);
4338 local_tlsdesc_gotent = elf32_nds32_local_tlsdesc_gotent (ibfd);
4339 for (symndx = 0; local_got < end_local_got;
4340 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent, ++symndx)
4341 {
4342 if (*local_got > 0)
4343 {
4344 int num_of_got_entry_needed = 0;
4345 *local_got = sgot->size;
4346 *local_tlsdesc_gotent = sgot->size;
4347
4348 /* TLS_NORMAL, and TLS_IE need one slot in .got. */
4349 if (*local_tls_type & (GOT_NORMAL | GOT_TLS_IE | GOT_TLS_IEGP))
4350 num_of_got_entry_needed = 1;
4351 /* TLS_GD, TLS_LD, and TLS_DESC need an 8-byte structure in the GOT. */
4352 else if (*local_tls_type & GOT_TLS_DESC)
4353 num_of_got_entry_needed = 2;
4354
4355 sgot->size += (num_of_got_entry_needed << 2);
4356
4357 /* non-relax-able TLS_DESCs need a slot in .rela.plt.
4358 others need a slot in .rela.got. */
4359 if (*local_tls_type == GOT_TLS_DESC)
4360 {
4361 if (bfd_link_pic (info))
4362 {
4363 if (htab->tls_desc_trampoline)
4364 {
4365 htab->num_tls_desc++;
4366 htab->root.srelplt->size += sizeof (Elf32_External_Rela);
4367 htab->tls_trampoline = -1;
4368 }
4369 else
4370 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
4371 }
4372 else
4373 {
4374 /* TLS_DESC -> TLS_LE */
4375 }
4376 }
4377 else
4378 {
4379 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
4380 }
4381 }
4382 else
4383 {
4384 *local_got = (bfd_vma) -1;
4385 *local_tlsdesc_gotent = (bfd_vma) -1;
4386 }
4387 }
4388 }
4389
4390 /* Allocate global sym .plt and .got entries, and space for global
4391 sym dynamic relocs. */
4392 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (void *) info);
4393
4394 /* For every jump slot reserved in the sgotplt, reloc_count is
4395 incremented. However, when we reserve space for TLS descriptors,
4396 it's not incremented, so in order to compute the space reserved
4397 for them, it suffices to multiply the reloc count by the jump
4398 slot size. */
4399 if (htab->tls_desc_trampoline && htab->root.srelplt)
4400 htab->sgotplt_jump_table_size = elf32_nds32_compute_jump_table_size (htab);
4401
4402 if (htab->tls_trampoline)
4403 {
4404 htab->tls_trampoline = htab->root.splt->size;
4405
4406 /* If we're not using lazy TLS relocations, don't generate the
4407 PLT and GOT entries they require. */
4408 if ((info->flags & DF_BIND_NOW))
4409 htab->root.tlsdesc_plt = 0;
4410 else
4411 {
4412 htab->root.tlsdesc_got = htab->root.sgot->size;
4413 htab->root.sgot->size += 4;
4414
4415 htab->root.tlsdesc_plt = htab->root.splt->size;
4416 htab->root.splt->size += 4 * ARRAY_SIZE (dl_tlsdesc_lazy_trampoline);
4417 }
4418 }
4419
4420 /* We now have determined the sizes of the various dynamic sections.
4421 Allocate memory for them. */
4422 /* The check_relocs and adjust_dynamic_symbol entry points have
4423 determined the sizes of the various dynamic sections. Allocate
4424 memory for them. */
4425 plt = FALSE;
4426 relocs = FALSE;
4427 for (s = dynobj->sections; s != NULL; s = s->next)
4428 {
4429 if ((s->flags & SEC_LINKER_CREATED) == 0)
4430 continue;
4431
4432 if (s == htab->root.splt)
4433 {
4434 /* Strip this section if we don't need it; see the
4435 comment below. */
4436 plt = s->size != 0;
4437 }
4438 else if (s == elf_hash_table (info)->sgot)
4439 {
4440 got_size += s->size;
4441 }
4442 else if (s == elf_hash_table (info)->sgotplt)
4443 {
4444 got_size += s->size;
4445 }
4446 else if (strncmp (bfd_section_name (s), ".rela", 5) == 0)
4447 {
4448 if (s->size != 0 && s != elf_hash_table (info)->srelplt)
4449 relocs = TRUE;
4450
4451 /* We use the reloc_count field as a counter if we need
4452 to copy relocs into the output file. */
4453 s->reloc_count = 0;
4454 }
4455 else
4456 {
4457 /* It's not one of our sections, so don't allocate space. */
4458 continue;
4459 }
4460
4461 if (s->size == 0)
4462 {
4463 /* If we don't need this section, strip it from the
4464 output file. This is mostly to handle .rela.bss and
4465 .rela.plt. We must create both sections in
4466 create_dynamic_sections, because they must be created
4467 before the linker maps input sections to output
4468 sections. The linker does that before
4469 adjust_dynamic_symbol is called, and it is that
4470 function which decides whether anything needs to go
4471 into these sections. */
4472 s->flags |= SEC_EXCLUDE;
4473 continue;
4474 }
4475
4476 /* Allocate memory for the section contents. We use bfd_zalloc
4477 here in case unused entries are not reclaimed before the
4478 section's contents are written out. This should not happen,
4479 but this way if it does, we get a R_NDS32_NONE reloc instead
4480 of garbage. */
4481 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
4482 if (s->contents == NULL)
4483 return FALSE;
4484 }
4485
4486
4487 if (htab->root.dynamic_sections_created)
4488 {
4489 /* Add some entries to the .dynamic section. We fill in the
4490 values later, in nds32_elf_finish_dynamic_sections, but we
4491 must add the entries now so that we get the correct size for
4492 the .dynamic section. The DT_DEBUG entry is filled in by the
4493 dynamic linker and used by the debugger. */
4494 #define add_dynamic_entry(TAG, VAL) \
4495 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4496
4497 if (bfd_link_executable (info))
4498 {
4499 if (!add_dynamic_entry (DT_DEBUG, 0))
4500 return FALSE;
4501 }
4502
4503 if (elf_hash_table (info)->splt->size != 0)
4504 {
4505 if (!add_dynamic_entry (DT_PLTGOT, 0)
4506 || !add_dynamic_entry (DT_PLTRELSZ, 0)
4507 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
4508 || !add_dynamic_entry (DT_JMPREL, 0))
4509 return FALSE;
4510 }
4511
4512 if (htab->tls_desc_trampoline && plt)
4513 {
4514 if (htab->root.tlsdesc_plt
4515 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
4516 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
4517 return FALSE;
4518 }
4519
4520 if (relocs)
4521 {
4522 if (!add_dynamic_entry (DT_RELA, 0)
4523 || !add_dynamic_entry (DT_RELASZ, 0)
4524 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
4525 return FALSE;
4526
4527 /* If any dynamic relocs apply to a read-only section,
4528 then we need a DT_TEXTREL entry. */
4529 if ((info->flags & DF_TEXTREL) == 0)
4530 elf_link_hash_traverse (&htab->root,
4531 _bfd_elf_maybe_set_textrel,
4532 (void *) info);
4533
4534 if ((info->flags & DF_TEXTREL) != 0)
4535 {
4536 if (!add_dynamic_entry (DT_TEXTREL, 0))
4537 return FALSE;
4538 }
4539 }
4540 }
4541 #undef add_dynamic_entry
4542
4543 return TRUE;
4544 }
4545
4546 static bfd_reloc_status_type
4547 nds32_relocate_contents (reloc_howto_type *howto, bfd *input_bfd,
4548 bfd_vma relocation, bfd_byte *location)
4549 {
4550 int size;
4551 bfd_vma x = 0;
4552 bfd_reloc_status_type flag;
4553 unsigned int rightshift = howto->rightshift;
4554 unsigned int bitpos = howto->bitpos;
4555
4556 /* If the size is negative, negate RELOCATION. This isn't very
4557 general. */
4558 if (howto->size < 0)
4559 relocation = -relocation;
4560
4561 /* Get the value we are going to relocate. */
4562 size = bfd_get_reloc_size (howto);
4563 switch (size)
4564 {
4565 default:
4566 abort ();
4567 break;
4568 case 0:
4569 return bfd_reloc_ok;
4570 case 2:
4571 x = bfd_getb16 (location);
4572 break;
4573 case 4:
4574 x = bfd_getb32 (location);
4575 break;
4576 }
4577
4578 /* Check for overflow. FIXME: We may drop bits during the addition
4579 which we don't check for. We must either check at every single
4580 operation, which would be tedious, or we must do the computations
4581 in a type larger than bfd_vma, which would be inefficient. */
4582 flag = bfd_reloc_ok;
4583 if (howto->complain_on_overflow != complain_overflow_dont)
4584 {
4585 bfd_vma addrmask, fieldmask, signmask, ss;
4586 bfd_vma a, b, sum;
4587
4588 /* Get the values to be added together. For signed and unsigned
4589 relocations, we assume that all values should be truncated to
4590 the size of an address. For bitfields, all the bits matter.
4591 See also bfd_check_overflow. */
4592 fieldmask = N_ONES (howto->bitsize);
4593 signmask = ~fieldmask;
4594 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
4595 a = (relocation & addrmask) >> rightshift;
4596 b = (x & howto->src_mask & addrmask) >> bitpos;
4597
4598 switch (howto->complain_on_overflow)
4599 {
4600 case complain_overflow_signed:
4601 /* If any sign bits are set, all sign bits must be set.
4602 That is, A must be a valid negative address after
4603 shifting. */
4604 signmask = ~(fieldmask >> 1);
4605 /* Fall through. */
4606
4607 case complain_overflow_bitfield:
4608 /* Much like the signed check, but for a field one bit
4609 wider. We allow a bitfield to represent numbers in the
4610 range -2**n to 2**n-1, where n is the number of bits in the
4611 field. Note that when bfd_vma is 32 bits, a 32-bit reloc
4612 can't overflow, which is exactly what we want. */
4613 ss = a & signmask;
4614 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
4615 flag = bfd_reloc_overflow;
4616
4617 /* We only need this next bit of code if the sign bit of B
4618 is below the sign bit of A. This would only happen if
4619 SRC_MASK had fewer bits than BITSIZE. Note that if
4620 SRC_MASK has more bits than BITSIZE, we can get into
4621 trouble; we would need to verify that B is in range, as
4622 we do for A above. */
4623 ss = ((~howto->src_mask) >> 1) & howto->src_mask;
4624 ss >>= bitpos;
4625
4626 /* Set all the bits above the sign bit. */
4627 b = (b ^ ss) - ss;
4628
4629 /* Now we can do the addition. */
4630 sum = a + b;
4631
4632 /* See if the result has the correct sign. Bits above the
4633 sign bit are junk now; ignore them. If the sum is
4634 positive, make sure we did not have all negative inputs;
4635 if the sum is negative, make sure we did not have all
4636 positive inputs. The test below looks only at the sign
4637 bits, and it really just
4638 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
4639
4640 We mask with addrmask here to explicitly allow an address
4641 wrap-around. The Linux kernel relies on it, and it is
4642 the only way to write assembler code which can run when
4643 loaded at a location 0x80000000 away from the location at
4644 which it is linked. */
4645 if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
4646 flag = bfd_reloc_overflow;
4647
4648 break;
4649
4650 case complain_overflow_unsigned:
4651 /* Checking for an unsigned overflow is relatively easy:
4652 trim the addresses and add, and trim the result as well.
4653 Overflow is normally indicated when the result does not
4654 fit in the field. However, we also need to consider the
4655 case when, e.g., fieldmask is 0x7fffffff or smaller, an
4656 input is 0x80000000, and bfd_vma is only 32 bits; then we
4657 will get sum == 0, but there is an overflow, since the
4658 inputs did not fit in the field. Instead of doing a
4659 separate test, we can check for this by or-ing in the
4660 operands when testing for the sum overflowing its final
4661 field. */
4662 sum = (a + b) & addrmask;
4663 if ((a | b | sum) & signmask)
4664 flag = bfd_reloc_overflow;
4665 break;
4666
4667 default:
4668 abort ();
4669 }
4670 }
4671
4672 /* Put RELOCATION in the right bits. */
4673 relocation >>= (bfd_vma) rightshift;
4674 relocation <<= (bfd_vma) bitpos;
4675
4676 /* Add RELOCATION to the right bits of X. */
4677 /* FIXME : 090616
4678 Because the relaxation may generate duplicate relocation at one address,
4679 an addition to immediate in the instruction may cause the relocation added
4680 several times.
4681 This bug should be fixed in assembler, but a check is also needed here. */
4682 if (howto->partial_inplace)
4683 x = ((x & ~howto->dst_mask)
4684 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
4685 else
4686 x = ((x & ~howto->dst_mask) | ((relocation) & howto->dst_mask));
4687
4688
4689 /* Put the relocated value back in the object file. */
4690 switch (size)
4691 {
4692 default:
4693 case 0:
4694 case 1:
4695 case 8:
4696 abort ();
4697 break;
4698 case 2:
4699 bfd_putb16 (x, location);
4700 break;
4701 case 4:
4702 bfd_putb32 (x, location);
4703 break;
4704 }
4705
4706 return flag;
4707 }
4708
4709 static bfd_reloc_status_type
4710 nds32_elf_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd,
4711 asection *input_section, bfd_byte *contents,
4712 bfd_vma address, bfd_vma value, bfd_vma addend)
4713 {
4714 bfd_vma relocation;
4715
4716 /* Sanity check the address. */
4717 if (address > bfd_get_section_limit (input_bfd, input_section))
4718 return bfd_reloc_outofrange;
4719
4720 /* This function assumes that we are dealing with a basic relocation
4721 against a symbol. We want to compute the value of the symbol to
4722 relocate to. This is just VALUE, the value of the symbol, plus
4723 ADDEND, any addend associated with the reloc. */
4724 relocation = value + addend;
4725
4726 /* If the relocation is PC relative, we want to set RELOCATION to
4727 the distance between the symbol (currently in RELOCATION) and the
4728 location we are relocating. If pcrel_offset is FALSE we do not
4729 need to subtract out the offset of the location within the
4730 section (which is just ADDRESS). */
4731 if (howto->pc_relative)
4732 {
4733 relocation -= (input_section->output_section->vma
4734 + input_section->output_offset);
4735 if (howto->pcrel_offset)
4736 relocation -= address;
4737 }
4738
4739 return nds32_relocate_contents (howto, input_bfd, relocation,
4740 contents + address);
4741 }
4742
4743 static bfd_boolean
4744 nds32_elf_output_symbol_hook (struct bfd_link_info *info,
4745 const char *name,
4746 Elf_Internal_Sym *elfsym ATTRIBUTE_UNUSED,
4747 asection *input_sec,
4748 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4749 {
4750 const char *source;
4751 FILE *sym_ld_script = NULL;
4752 struct elf_nds32_link_hash_table *table;
4753
4754 table = nds32_elf_hash_table (info);
4755 sym_ld_script = table->sym_ld_script;
4756 if (!sym_ld_script)
4757 return TRUE;
4758
4759 if (!h || !name || *name == '\0')
4760 return TRUE;
4761
4762 if (input_sec->flags & SEC_EXCLUDE)
4763 return TRUE;
4764
4765 if (!check_start_export_sym)
4766 {
4767 fprintf (sym_ld_script, "SECTIONS\n{\n");
4768 check_start_export_sym = 1;
4769 }
4770
4771 if (h->root.type == bfd_link_hash_defined
4772 || h->root.type == bfd_link_hash_defweak)
4773 {
4774 if (!h->root.u.def.section->output_section)
4775 return TRUE;
4776
4777 if (bfd_is_const_section (input_sec))
4778 source = input_sec->name;
4779 else
4780 source = bfd_get_filename (input_sec->owner);
4781
4782 fprintf (sym_ld_script, "\t%s = 0x%08lx;\t /* %s */\n",
4783 h->root.root.string,
4784 (long) (h->root.u.def.value
4785 + h->root.u.def.section->output_section->vma
4786 + h->root.u.def.section->output_offset), source);
4787 }
4788
4789 return TRUE;
4790 }
4791
4792 /* Relocate an NDS32/D ELF section.
4793 There is some attempt to make this function usable for many architectures,
4794 both for RELA and REL type relocs, if only to serve as a learning tool.
4795
4796 The RELOCATE_SECTION function is called by the new ELF backend linker
4797 to handle the relocations for a section.
4798
4799 The relocs are always passed as Rela structures; if the section
4800 actually uses Rel structures, the r_addend field will always be
4801 zero.
4802
4803 This function is responsible for adjust the section contents as
4804 necessary, and (if using Rela relocs and generating a
4805 relocatable output file) adjusting the reloc addend as
4806 necessary.
4807
4808 This function does not have to worry about setting the reloc
4809 address or the reloc symbol index.
4810
4811 LOCAL_SYMS is a pointer to the swapped in local symbols.
4812
4813 LOCAL_SECTIONS is an array giving the section in the input file
4814 corresponding to the st_shndx field of each local symbol.
4815
4816 The global hash table entry for the global symbols can be found
4817 via elf_sym_hashes (input_bfd).
4818
4819 When generating relocatable output, this function must handle
4820 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
4821 going to be the section symbol corresponding to the output
4822 section, which means that the addend must be adjusted
4823 accordingly. */
4824
4825 /* Return the base VMA address which should be subtracted from real addresses
4826 when resolving @dtpoff relocation.
4827 This is PT_TLS segment p_vaddr. */
4828
4829 /* Return the relocation value for @tpoff relocation
4830 if STT_TLS virtual address is ADDRESS. */
4831
4832 /* Return the relocation value for @gottpoff relocation
4833 if STT_TLS virtual address is ADDRESS. */
4834
4835 static bfd_vma
4836 gottpoff (struct bfd_link_info *info, bfd_vma address)
4837 {
4838 bfd_vma tp_base;
4839 bfd_vma tp_offset;
4840
4841 /* If tls_sec is NULL, we should have signalled an error already. */
4842 if (elf_hash_table (info)->tls_sec == NULL)
4843 return 0;
4844
4845 tp_base = elf_hash_table (info)->tls_sec->vma;
4846 tp_offset = address - tp_base;
4847
4848 return tp_offset;
4849 }
4850
4851 static bfd_boolean
4852 patch_tls_desc_to_ie (bfd_byte *contents, Elf_Internal_Rela *rel, bfd *ibfd)
4853 {
4854 /* TLS_GD/TLS_LD model #1
4855 46 00 00 00 sethi $r0,#0x0
4856 58 00 00 00 ori $r0,$r0,#0x0
4857 40 00 74 00 add $r0,$r0,$gp
4858 04 10 00 00 lwi $r1,[$r0+#0x0]
4859 4b e0 04 01 jral $lp,$r1 */
4860
4861 /* TLS_GD/TLS_LD model #2
4862 46 00 00 00 sethi $r0,#0x0
4863 58 00 00 00 ori $r0,$r0,#0x0
4864 38 10 74 02 lw $r1,[$r0+($gp<<#0x0)]
4865 40 00 74 00 add $r0,$r0,$gp
4866 4b e0 04 01 jral $lp,$r1 */
4867
4868 /* TLS_IE model (non-PIC)
4869 46 00 00 00 sethi $r0,#0x0
4870 04 00 00 00 lwi $r0,[$r0+#0x0]
4871 38 00 64 02 lw $r0,[$r0+($r25<<#0x0)] */
4872
4873 /* TLS_IE model (PIC)
4874 46 00 00 00 sethi $r0,#0x0
4875 58 00 00 00 ori $r0,$r0,#0x0
4876 38 00 74 02 lw $r0,[$r0+($gp<<#0x0)]
4877 38 00 64 02 lw $r0,[$r0+($r25<<#0x0)] */
4878
4879 /* TLS_GD_TO_IE model
4880 46 00 00 00 sethi $r0,#0x0
4881 58 00 00 00 ori $r0,$r0,#0x0
4882 40 00 74 00 add $r0,$rM,$gp
4883 04 00 00 01 lwi $r0,[$r0+#0x4]
4884 40 00 64 00 add $r0,$r0,$r25 */
4885
4886 bfd_boolean rz = FALSE;
4887
4888 typedef struct
4889 {
4890 uint32_t opcode;
4891 uint32_t mask;
4892 } pat_t;
4893
4894 uint32_t patch[3] =
4895 {
4896 0x40007400, /* add $r0,$rM,$gp */
4897 0x04000001, /* lwi $r0,[$r0+#0x4] */
4898 0x40006400, /* add $r0,$r0,$r25 */
4899 };
4900
4901 pat_t mode0[3] =
4902 {
4903 { 0x40000000, 0xfe0003ff },
4904 { 0x04000000, 0xfe000000 },
4905 { 0x4be00001, 0xffff83ff },
4906 };
4907
4908 pat_t mode1[3] =
4909 {
4910 { 0x38007402, 0xfe007fff },
4911 { 0x40007400, 0xfe007fff },
4912 { 0x4be00001, 0xffff83ff },
4913 };
4914
4915 unsigned char *p = contents + rel->r_offset;
4916
4917 uint32_t insn;
4918 uint32_t regidx = 0;
4919 insn = bfd_getb32 (p);
4920 if (INSN_SETHI == (0xfe0fffffu & insn))
4921 {
4922 regidx = 0x1f & (insn >> 20);
4923 p += 4;
4924 }
4925
4926 insn = bfd_getb32 (p);
4927 if (INSN_ORI == (0xfe007fffu & insn))
4928 {
4929 regidx = 0x1f & (insn >> 20);
4930 p += 4;
4931 }
4932
4933 if (patch[2] == bfd_getb32 (p + 8)) /* Character instruction. */
4934 {
4935 /* already patched? */
4936 if ((patch[0] == (0xfff07fffu & bfd_getb32 (p + 0))) &&
4937 (patch[1] == bfd_getb32 (p + 4)))
4938 rz = TRUE;
4939 }
4940 else if (mode0[0].opcode == (mode0[0].mask & bfd_getb32 (p + 0)))
4941 {
4942 if ((mode0[1].opcode == (mode0[1].mask & bfd_getb32 (p + 4))) &&
4943 (mode0[2].opcode == (mode0[2].mask & bfd_getb32 (p + 8))))
4944 {
4945 bfd_putb32 (patch[0] | (regidx << 15), p + 0);
4946 bfd_putb32 (patch[1], p + 4);
4947 bfd_putb32 (patch[2], p + 8);
4948 rz = TRUE;
4949 }
4950 }
4951 else if (mode1[0].opcode == (mode1[0].mask & bfd_getb32 (p + 0)))
4952 {
4953 if ((mode1[1].opcode == (mode1[1].mask & bfd_getb32 (p + 4))) &&
4954 (mode1[2].opcode == (mode1[2].mask & bfd_getb32 (p + 8))))
4955 {
4956 bfd_putb32 (patch[0] | (regidx << 15), p + 0);
4957 bfd_putb32 (patch[1], p + 4);
4958 bfd_putb32 (patch[2], p + 8);
4959 rz = TRUE;
4960 }
4961 }
4962
4963 if (!rz)
4964 {
4965 printf ("%s: %s @ 0x%08x\n", __func__, bfd_get_filename (ibfd),
4966 (int) rel->r_offset);
4967 BFD_ASSERT(0); /* Unsupported pattern. */
4968 }
4969
4970 return rz;
4971 }
4972
4973 static enum elf_nds32_tls_type
4974 get_tls_type (enum elf_nds32_reloc_type r_type, struct elf_link_hash_entry *h);
4975
4976 static unsigned int
4977 ones32 (register unsigned int x)
4978 {
4979 /* 32-bit recursive reduction using SWAR...
4980 but first step is mapping 2-bit values
4981 into sum of 2 1-bit values in sneaky way. */
4982 x -= ((x >> 1) & 0x55555555);
4983 x = (((x >> 2) & 0x33333333) + (x & 0x33333333));
4984 x = (((x >> 4) + x) & 0x0f0f0f0f);
4985 x += (x >> 8);
4986 x += (x >> 16);
4987 return (x & 0x0000003f);
4988 }
4989
4990 #if !HAVE_FLS
4991 static unsigned int
4992 fls (register unsigned int x)
4993 {
4994 return ffs (x & (-x));
4995 }
4996 #endif /* !HAVE_FLS */
4997
4998 #define nds32_elf_local_tlsdesc_gotent(bfd) \
4999 (elf_nds32_tdata (bfd)->local_tlsdesc_gotent)
5000
5001 static bfd_boolean
5002 nds32_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
5003 struct bfd_link_info * info,
5004 bfd * input_bfd,
5005 asection * input_section,
5006 bfd_byte * contents,
5007 Elf_Internal_Rela * relocs,
5008 Elf_Internal_Sym * local_syms,
5009 asection ** local_sections)
5010 {
5011 Elf_Internal_Shdr *symtab_hdr;
5012 struct elf_link_hash_entry **sym_hashes;
5013 Elf_Internal_Rela *rel, *relend;
5014 bfd_boolean ret = TRUE; /* Assume success. */
5015 int align = 0;
5016 bfd_reloc_status_type r;
5017 const char *errmsg = NULL;
5018 bfd_vma gp;
5019 struct elf_link_hash_table *ehtab;
5020 struct elf_nds32_link_hash_table *htab;
5021 bfd *dynobj;
5022 bfd_vma *local_got_offsets;
5023 asection *sgot, *splt, *sreloc;
5024 bfd_vma high_address;
5025 struct elf_nds32_link_hash_table *table;
5026 int eliminate_gc_relocs;
5027 bfd_vma fpbase_addr;
5028
5029 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5030 sym_hashes = elf_sym_hashes (input_bfd);
5031 ehtab = elf_hash_table (info);
5032 htab = nds32_elf_hash_table (info);
5033 high_address = bfd_get_section_limit (input_bfd, input_section);
5034
5035 dynobj = htab->root.dynobj;
5036 local_got_offsets = elf_local_got_offsets (input_bfd);
5037
5038 sgot = ehtab->sgot;
5039 splt = ehtab->splt;
5040 sreloc = NULL;
5041
5042 rel = relocs;
5043 relend = relocs + input_section->reloc_count;
5044
5045 table = nds32_elf_hash_table (info);
5046 eliminate_gc_relocs = table->eliminate_gc_relocs;
5047
5048 /* By this time, we can adjust the value of _SDA_BASE_. */
5049 /* Explain _SDA_BASE_ */
5050 if ((!bfd_link_relocatable (info)))
5051 {
5052 is_SDA_BASE_set = 1;
5053 r = nds32_elf_final_sda_base (output_bfd, info, &gp, TRUE);
5054 if (r != bfd_reloc_ok)
5055 return FALSE;
5056 }
5057
5058 /* Do TLS model conversion once at first. */
5059 nds32_elf_unify_tls_model (input_bfd, input_section, contents, info);
5060
5061 /* Use gp as fp to prevent truncated fit. Because in relaxation time
5062 the fp value is set as gp, and it has be reverted for instruction
5063 setting fp. */
5064 fpbase_addr = elf_gp (output_bfd);
5065
5066 /* Deal with (dynamic) relocations. */
5067 for (rel = relocs; rel < relend; rel++)
5068 {
5069 enum elf_nds32_reloc_type r_type;
5070 reloc_howto_type *howto = NULL;
5071 unsigned long r_symndx;
5072 struct elf_link_hash_entry *h = NULL;
5073 Elf_Internal_Sym *sym = NULL;
5074 asection *sec;
5075 bfd_vma relocation;
5076 bfd_vma relocation_sym = 0xdeadbeef;
5077 Elf_Internal_Rela *lorel;
5078 bfd_vma off;
5079
5080 /* We can't modify r_addend here as elf_link_input_bfd has an assert to
5081 ensure it's zero (we use REL relocs, not RELA). Therefore this
5082 should be assigning zero to `addend', but for clarity we use
5083 `r_addend'. */
5084
5085 bfd_vma addend = rel->r_addend;
5086 bfd_vma offset = rel->r_offset;
5087
5088 r_type = ELF32_R_TYPE (rel->r_info);
5089 if (r_type >= R_NDS32_max)
5090 {
5091 /* xgettext:c-format */
5092 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
5093 input_bfd, r_type);
5094 bfd_set_error (bfd_error_bad_value);
5095 ret = FALSE;
5096 continue;
5097 }
5098
5099 if (r_type == R_NDS32_GNU_VTENTRY
5100 || r_type == R_NDS32_GNU_VTINHERIT
5101 || r_type == R_NDS32_NONE
5102 || r_type == R_NDS32_RELA_GNU_VTENTRY
5103 || r_type == R_NDS32_RELA_GNU_VTINHERIT
5104 || (r_type >= R_NDS32_INSN16 && r_type <= R_NDS32_25_FIXED_RELA)
5105 || r_type == R_NDS32_DATA
5106 || r_type == R_NDS32_TRAN)
5107 continue;
5108
5109 /* If we enter the fp-as-gp region. Resolve the address
5110 of best fp-base. */
5111 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_BEGIN
5112 && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
5113 {
5114 int dist;
5115
5116 /* Distance to relocation of best fp-base is encoded in R_SYM. */
5117 dist = rel->r_addend >> 16;
5118 fpbase_addr = calculate_memory_address (input_bfd, rel + dist,
5119 local_syms, symtab_hdr);
5120 }
5121 else if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_END
5122 && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
5123 {
5124 fpbase_addr = elf_gp (output_bfd);
5125 }
5126
5127 /* Skip the relocations used for relaxation. */
5128 /* We have to update LONGCALL and LONGJUMP
5129 relocations when generating the relocatable files. */
5130 if (!bfd_link_relocatable (info)
5131 && (r_type >= R_NDS32_RELAX_ENTRY
5132 || (r_type >= R_NDS32_LONGCALL4
5133 && r_type <= R_NDS32_LONGJUMP7)))
5134 continue;
5135
5136 howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
5137 r_symndx = ELF32_R_SYM (rel->r_info);
5138
5139 /* This is a final link. */
5140 sym = NULL;
5141 sec = NULL;
5142 h = NULL;
5143
5144 if (r_symndx < symtab_hdr->sh_info)
5145 {
5146 /* Local symbol. */
5147 sym = local_syms + r_symndx;
5148 sec = local_sections[r_symndx];
5149
5150 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
5151 addend = rel->r_addend;
5152
5153 /* keep symbol location for static TLS_IE GOT entry */
5154 relocation_sym = relocation;
5155 if (bfd_link_relocatable (info))
5156 {
5157 /* This is a relocatable link. We don't have to change
5158 anything, unless the reloc is against a section symbol,
5159 in which case we have to adjust according to where the
5160 section symbol winds up in the output section. */
5161 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5162 rel->r_addend += sec->output_offset + sym->st_value;
5163
5164 continue;
5165 }
5166 }
5167 else
5168 {
5169 /* External symbol. */
5170 if (bfd_link_relocatable (info))
5171 continue;
5172 bfd_boolean warned, ignored, unresolved_reloc;
5173 int symndx = r_symndx - symtab_hdr->sh_info;
5174
5175 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
5176 r_symndx, symtab_hdr, sym_hashes, h, sec,
5177 relocation, unresolved_reloc, warned,
5178 ignored);
5179
5180 /* keep symbol location for static TLS_IE GOT entry */
5181 relocation_sym = relocation;
5182
5183 /* la $fp, _FP_BASE_ is per-function (region).
5184 Handle it specially. */
5185 switch ((int) r_type)
5186 {
5187 case R_NDS32_HI20_RELA:
5188 case R_NDS32_LO12S0_RELA:
5189 if (strcmp (elf_sym_hashes (input_bfd)[symndx]->root.root.string,
5190 FP_BASE_NAME) == 0)
5191 {
5192 if (!bfd_link_pie (info))
5193 {
5194 _bfd_error_handler
5195 ("%pB: warning: _FP_BASE_ setting insns relaxation failed.",
5196 input_bfd);
5197 }
5198 relocation = fpbase_addr;
5199 }
5200 break;
5201 case R_NDS32_SDA19S0_RELA:
5202 case R_NDS32_SDA15S0_RELA:
5203 case R_NDS32_20_RELA:
5204 if (strcmp (elf_sym_hashes (input_bfd)[symndx]->root.root.string,
5205 FP_BASE_NAME) == 0)
5206 {
5207 relocation = fpbase_addr;
5208 break;
5209 }
5210 }
5211 }
5212
5213 /* Sanity check the address. */
5214 if (offset > high_address)
5215 {
5216 r = bfd_reloc_outofrange;
5217 goto check_reloc;
5218 }
5219
5220 if (r_type >= R_NDS32_RELAX_ENTRY)
5221 continue;
5222
5223 switch ((int) r_type)
5224 {
5225 case R_NDS32_GOTOFF:
5226 /* Relocation is relative to the start of the global offset
5227 table (for ld24 rx, #uimm24), e.g. access at label+addend
5228
5229 ld24 rx. #label@GOTOFF + addend
5230 sub rx, r12. */
5231 case R_NDS32_GOTOFF_HI20:
5232 case R_NDS32_GOTOFF_LO12:
5233 case R_NDS32_GOTOFF_LO15:
5234 case R_NDS32_GOTOFF_LO19:
5235 BFD_ASSERT (sgot != NULL);
5236
5237 relocation -= elf_gp (output_bfd);
5238 break;
5239
5240 case R_NDS32_9_PLTREL:
5241 case R_NDS32_25_PLTREL:
5242 /* Relocation is to the entry for this symbol in the
5243 procedure linkage table. */
5244
5245 /* The native assembler will generate a 25_PLTREL reloc
5246 for a local symbol if you assemble a call from one
5247 section to another when using -K pic. */
5248 if (h == NULL)
5249 break;
5250
5251 if (h->forced_local)
5252 break;
5253
5254 /* We didn't make a PLT entry for this symbol. This
5255 happens when statically linking PIC code, or when
5256 using -Bsymbolic. */
5257 if (h->plt.offset == (bfd_vma) - 1)
5258 break;
5259
5260 relocation = (splt->output_section->vma
5261 + splt->output_offset + h->plt.offset);
5262 break;
5263
5264 case R_NDS32_PLT_GOTREL_HI20:
5265 case R_NDS32_PLT_GOTREL_LO12:
5266 case R_NDS32_PLT_GOTREL_LO15:
5267 case R_NDS32_PLT_GOTREL_LO19:
5268 case R_NDS32_PLT_GOTREL_LO20:
5269 if (h == NULL
5270 || h->forced_local
5271 || h->plt.offset == (bfd_vma) -1
5272 || (bfd_link_pie (info) && h->def_regular))
5273 {
5274 /* Maybe we should find better checking to optimize
5275 PIE PLT relocations. */
5276 /* We didn't make a PLT entry for this symbol. This
5277 happens when statically linking PIC code, or when
5278 using -Bsymbolic. */
5279 if (h)
5280 h->plt.offset = (bfd_vma) -1; /* Cancel PLT trampoline. */
5281 relocation -= elf_gp (output_bfd);
5282 break;
5283 }
5284
5285 relocation = (splt->output_section->vma
5286 + splt->output_offset + h->plt.offset);
5287
5288 relocation -= elf_gp (output_bfd);
5289 break;
5290
5291 case R_NDS32_PLTREL_HI20:
5292 case R_NDS32_PLTREL_LO12:
5293
5294 /* Relocation is to the entry for this symbol in the
5295 procedure linkage table. */
5296
5297 /* The native assembler will generate a 25_PLTREL reloc
5298 for a local symbol if you assemble a call from one
5299 section to another when using -K pic. */
5300 if (h == NULL)
5301 break;
5302
5303 if (h->forced_local)
5304 break;
5305
5306 if (h->plt.offset == (bfd_vma) - 1)
5307 /* We didn't make a PLT entry for this symbol. This
5308 happens when statically linking PIC code, or when
5309 using -Bsymbolic. */
5310 break;
5311
5312 if (splt == NULL)
5313 break;
5314
5315 relocation = (splt->output_section->vma
5316 + splt->output_offset
5317 + h->plt.offset + 4)
5318 - (input_section->output_section->vma
5319 + input_section->output_offset
5320 + rel->r_offset);
5321
5322 break;
5323
5324 case R_NDS32_GOTPC20:
5325 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
5326 ld24 rx,#_GLOBAL_OFFSET_TABLE_ */
5327 relocation = elf_gp (output_bfd);
5328 break;
5329
5330 case R_NDS32_GOTPC_HI20:
5331 case R_NDS32_GOTPC_LO12:
5332 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
5333 bl .+4
5334 seth rx,#high(_GLOBAL_OFFSET_TABLE_)
5335 or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
5336 or
5337 bl .+4
5338 seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
5339 add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4) */
5340 relocation = elf_gp (output_bfd);
5341 relocation -= (input_section->output_section->vma
5342 + input_section->output_offset + rel->r_offset);
5343 break;
5344
5345 case R_NDS32_GOT20:
5346 /* Fall through. */
5347 case R_NDS32_GOT_HI20:
5348 case R_NDS32_GOT_LO12:
5349 case R_NDS32_GOT_LO15:
5350 case R_NDS32_GOT_LO19:
5351 /* Relocation is to the entry for this symbol in the global
5352 offset table. */
5353 BFD_ASSERT (sgot != NULL);
5354
5355 if (h != NULL)
5356 {
5357 /* External symbol */
5358 bfd_boolean dyn;
5359
5360 off = h->got.offset;
5361 BFD_ASSERT (off != (bfd_vma) - 1);
5362 dyn = htab->root.dynamic_sections_created;
5363 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
5364 bfd_link_pic (info),
5365 h)
5366 || (bfd_link_pic (info)
5367 && (info->symbolic
5368 || h->dynindx == -1
5369 || h->forced_local) && h->def_regular))
5370 {
5371 /* This is actually a static link, or it is a
5372 -Bsymbolic link and the symbol is defined
5373 locally, or the symbol was forced to be local
5374 because of a version file. We must initialize
5375 this entry in the global offset table. Since the
5376 offset must always be a multiple of 4, we use the
5377 least significant bit to record whether we have
5378 initialized it already.
5379
5380 When doing a dynamic link, we create a .rela.got
5381 relocation entry to initialize the value. This
5382 is done in the finish_dynamic_symbol routine. */
5383 if ((off & 1) != 0) /* clear LSB */
5384 off &= ~1;
5385 else
5386 {
5387 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5388 h->got.offset |= 1;
5389 }
5390 }
5391 relocation = sgot->output_section->vma + sgot->output_offset + off
5392 - elf_gp (output_bfd);
5393 }
5394 else
5395 {
5396 /* Local symbol */
5397 bfd_byte *loc;
5398
5399 BFD_ASSERT (local_got_offsets != NULL
5400 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5401
5402 off = local_got_offsets[r_symndx];
5403
5404 /* The offset must always be a multiple of 4. We use
5405 the least significant bit to record whether we have
5406 already processed this entry. */
5407 if ((off & 1) != 0) /* clear LSB */
5408 off &= ~1;
5409 else
5410 {
5411 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5412
5413 if (bfd_link_pic (info))
5414 {
5415 asection *srelgot;
5416 Elf_Internal_Rela outrel;
5417
5418 /* We need to generate a R_NDS32_RELATIVE reloc
5419 for the dynamic linker. */
5420 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5421 BFD_ASSERT (srelgot != NULL);
5422
5423 outrel.r_offset = (elf_gp (output_bfd)
5424 + sgot->output_offset + off);
5425 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5426 outrel.r_addend = relocation;
5427 loc = srelgot->contents;
5428 loc +=
5429 srelgot->reloc_count * sizeof (Elf32_External_Rela);
5430 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5431 ++srelgot->reloc_count;
5432 }
5433 local_got_offsets[r_symndx] |= 1;
5434 }
5435 relocation = sgot->output_section->vma + sgot->output_offset + off
5436 - elf_gp (output_bfd);
5437 }
5438
5439 break;
5440
5441 case R_NDS32_16_RELA:
5442 case R_NDS32_20_RELA:
5443 case R_NDS32_5_RELA:
5444 case R_NDS32_32_RELA:
5445 case R_NDS32_9_PCREL_RELA:
5446 case R_NDS32_WORD_9_PCREL_RELA:
5447 case R_NDS32_10_UPCREL_RELA:
5448 case R_NDS32_15_PCREL_RELA:
5449 case R_NDS32_17_PCREL_RELA:
5450 case R_NDS32_25_PCREL_RELA:
5451 case R_NDS32_HI20_RELA:
5452 case R_NDS32_LO12S3_RELA:
5453 case R_NDS32_LO12S2_RELA:
5454 case R_NDS32_LO12S2_DP_RELA:
5455 case R_NDS32_LO12S2_SP_RELA:
5456 case R_NDS32_LO12S1_RELA:
5457 case R_NDS32_LO12S0_RELA:
5458 case R_NDS32_LO12S0_ORI_RELA:
5459 if (bfd_link_pic (info) && r_symndx != 0
5460 && (input_section->flags & SEC_ALLOC) != 0
5461 && (eliminate_gc_relocs == 0
5462 || (sec && (sec->flags & SEC_EXCLUDE) == 0))
5463 && ((r_type != R_NDS32_9_PCREL_RELA
5464 && r_type != R_NDS32_WORD_9_PCREL_RELA
5465 && r_type != R_NDS32_10_UPCREL_RELA
5466 && r_type != R_NDS32_15_PCREL_RELA
5467 && r_type != R_NDS32_17_PCREL_RELA
5468 && r_type != R_NDS32_25_PCREL_RELA
5469 && !(r_type == R_NDS32_32_RELA
5470 && strcmp (input_section->name, ".eh_frame") == 0))
5471 || (h != NULL && h->dynindx != -1
5472 && (!info->symbolic || !h->def_regular))))
5473 {
5474 Elf_Internal_Rela outrel;
5475 bfd_boolean skip, relocate;
5476 bfd_byte *loc;
5477
5478 /* When generating a shared object, these relocations
5479 are copied into the output file to be resolved at run
5480 time. */
5481
5482 if (sreloc == NULL)
5483 {
5484 const char *name;
5485
5486 name = bfd_elf_string_from_elf_section
5487 (input_bfd, elf_elfheader (input_bfd)->e_shstrndx,
5488 elf_section_data (input_section)->rela.hdr->sh_name);
5489 if (name == NULL)
5490 return FALSE;
5491
5492 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5493 && strcmp (bfd_section_name (input_section),
5494 name + 5) == 0);
5495
5496 sreloc = bfd_get_section_by_name (dynobj, name);
5497 BFD_ASSERT (sreloc != NULL);
5498 }
5499
5500 skip = FALSE;
5501 relocate = FALSE;
5502
5503 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
5504 info,
5505 input_section,
5506 rel->r_offset);
5507 if (outrel.r_offset == (bfd_vma) - 1)
5508 skip = TRUE;
5509 else if (outrel.r_offset == (bfd_vma) - 2)
5510 skip = TRUE, relocate = TRUE;
5511 outrel.r_offset += (input_section->output_section->vma
5512 + input_section->output_offset);
5513
5514 if (skip)
5515 memset (&outrel, 0, sizeof outrel);
5516 else if (r_type == R_NDS32_17_PCREL_RELA
5517 || r_type == R_NDS32_15_PCREL_RELA
5518 || r_type == R_NDS32_25_PCREL_RELA)
5519 {
5520 BFD_ASSERT (h != NULL && h->dynindx != -1);
5521 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
5522 outrel.r_addend = rel->r_addend;
5523 }
5524 else
5525 {
5526 /* h->dynindx may be -1 if this symbol was marked to
5527 become local. */
5528 if (h == NULL
5529 || ((info->symbolic || h->dynindx == -1)
5530 && h->def_regular)
5531 || (bfd_link_pie (info) && h->def_regular))
5532 {
5533 relocate = TRUE;
5534 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5535 outrel.r_addend = relocation + rel->r_addend;
5536
5537 if (h)
5538 {
5539 h->plt.offset = (bfd_vma) -1; /* cancel PLT trampoline. */
5540
5541 BFD_ASSERT (sgot != NULL);
5542 /* If we did not allocate got entry for the symbol,
5543 we can not fill the nonexistent got entry. */
5544 if (h->got.offset != (bfd_vma) -1
5545 && (h->got.offset & 1) == 0)
5546 {
5547 bfd_put_32 (output_bfd, outrel.r_addend,
5548 sgot->contents + h->got.offset);
5549 }
5550 }
5551 }
5552 else
5553 {
5554 if (h->dynindx == -1)
5555 {
5556 _bfd_error_handler
5557 (_("%pB: relocation %s against `%s' can not be used when "
5558 "making a shared object; recompile with -fPIC"),
5559 input_bfd, nds32_elf_howto_table[r_type].name, h->root.root.string);
5560 bfd_set_error (bfd_error_bad_value);
5561 return FALSE;
5562 }
5563
5564 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
5565 outrel.r_addend = rel->r_addend;
5566 }
5567 }
5568
5569 loc = sreloc->contents;
5570 loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
5571 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5572 ++sreloc->reloc_count;
5573
5574 /* If this reloc is against an external symbol, we do
5575 not want to fiddle with the addend. Otherwise, we
5576 need to include the symbol value so that it becomes
5577 an addend for the dynamic reloc. */
5578 if (!relocate)
5579 continue;
5580 }
5581 break;
5582
5583 case R_NDS32_25_ABS_RELA:
5584 if (bfd_link_pic (info))
5585 {
5586 _bfd_error_handler
5587 (_("%pB: warning: %s unsupported in shared mode"),
5588 input_bfd, "R_NDS32_25_ABS_RELA");
5589 return FALSE;
5590 }
5591 break;
5592
5593 case R_NDS32_9_PCREL:
5594 r = nds32_elf_do_9_pcrel_reloc (input_bfd, howto, input_section,
5595 contents, offset,
5596 sec, relocation, addend);
5597 goto check_reloc;
5598
5599 case R_NDS32_HI20:
5600 /* We allow an arbitrary number of HI20 relocs before the
5601 LO12 reloc. This permits gcc to emit the HI and LO relocs
5602 itself. */
5603 for (lorel = rel + 1;
5604 (lorel < relend
5605 && ELF32_R_TYPE (lorel->r_info) == R_NDS32_HI20); lorel++)
5606 continue;
5607 if (lorel < relend
5608 && (ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S3
5609 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S2
5610 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S1
5611 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S0))
5612 {
5613 nds32_elf_relocate_hi20 (input_bfd, r_type, rel, lorel,
5614 contents, relocation + addend);
5615 r = bfd_reloc_ok;
5616 }
5617 else
5618 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5619 contents, offset, relocation,
5620 addend);
5621 goto check_reloc;
5622
5623 case R_NDS32_GOT17S2_RELA:
5624 case R_NDS32_GOT15S2_RELA:
5625 BFD_ASSERT (sgot != NULL);
5626
5627 if (h != NULL)
5628 {
5629 bfd_boolean dyn;
5630
5631 off = h->got.offset;
5632 BFD_ASSERT (off != (bfd_vma) - 1);
5633
5634 dyn = htab->root.dynamic_sections_created;
5635 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL
5636 (dyn, bfd_link_pic (info), h)
5637 || (bfd_link_pic (info)
5638 && (info->symbolic
5639 || h->dynindx == -1
5640 || h->forced_local)
5641 && h->def_regular))
5642 {
5643 /* This is actually a static link, or it is a
5644 -Bsymbolic link and the symbol is defined
5645 locally, or the symbol was forced to be local
5646 because of a version file. We must initialize
5647 this entry in the global offset table. Since the
5648 offset must always be a multiple of 4, we use the
5649 least significant bit to record whether we have
5650 initialized it already.
5651
5652 When doing a dynamic link, we create a .rela.got
5653 relocation entry to initialize the value. This
5654 is done in the finish_dynamic_symbol routine. */
5655 if ((off & 1) != 0)
5656 off &= ~1;
5657 else
5658 {
5659 bfd_put_32 (output_bfd, relocation,
5660 sgot->contents + off);
5661 h->got.offset |= 1;
5662 }
5663 }
5664 }
5665 else
5666 {
5667 bfd_byte *loc;
5668
5669 BFD_ASSERT (local_got_offsets != NULL
5670 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5671
5672 off = local_got_offsets[r_symndx];
5673
5674 /* The offset must always be a multiple of 4. We use
5675 the least significant bit to record whether we have
5676 already processed this entry. */
5677 if ((off & 1) != 0)
5678 off &= ~1;
5679 else
5680 {
5681 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5682
5683 if (bfd_link_pic (info))
5684 {
5685 asection *srelgot;
5686 Elf_Internal_Rela outrel;
5687
5688 /* We need to generate a R_NDS32_RELATIVE reloc
5689 for the dynamic linker. */
5690 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5691 BFD_ASSERT (srelgot != NULL);
5692
5693 outrel.r_offset = (elf_gp (output_bfd)
5694 + sgot->output_offset + off);
5695 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5696 outrel.r_addend = relocation;
5697 loc = srelgot->contents;
5698 loc +=
5699 srelgot->reloc_count * sizeof (Elf32_External_Rela);
5700 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5701 ++srelgot->reloc_count;
5702 }
5703 local_got_offsets[r_symndx] |= 1;
5704 }
5705 }
5706 relocation = sgot->output_section->vma + sgot->output_offset + off
5707 - elf_gp (output_bfd);
5708
5709 if (relocation & align)
5710 {
5711 /* Incorrect alignment. */
5712 _bfd_error_handler
5713 (_("%pB: warning: unaligned access to GOT entry"), input_bfd);
5714 ret = FALSE;
5715 r = bfd_reloc_dangerous;
5716 goto check_reloc;
5717 }
5718 break;
5719
5720 case R_NDS32_SDA16S3_RELA:
5721 case R_NDS32_SDA15S3_RELA:
5722 case R_NDS32_SDA15S3:
5723 align = 0x7;
5724 goto handle_sda;
5725
5726 case R_NDS32_SDA17S2_RELA:
5727 case R_NDS32_SDA15S2_RELA:
5728 case R_NDS32_SDA12S2_SP_RELA:
5729 case R_NDS32_SDA12S2_DP_RELA:
5730 case R_NDS32_SDA15S2:
5731 case R_NDS32_SDA_FP7U2_RELA:
5732 align = 0x3;
5733 goto handle_sda;
5734
5735 case R_NDS32_SDA18S1_RELA:
5736 case R_NDS32_SDA15S1_RELA:
5737 case R_NDS32_SDA15S1:
5738 align = 0x1;
5739 goto handle_sda;
5740
5741 case R_NDS32_SDA19S0_RELA:
5742 case R_NDS32_SDA15S0_RELA:
5743 case R_NDS32_SDA15S0:
5744 align = 0x0;
5745 handle_sda:
5746 BFD_ASSERT (sec != NULL);
5747
5748 /* If the symbol is in the abs section, the out_bfd will be null.
5749 This happens when the relocation has a symbol@GOTOFF. */
5750 r = nds32_elf_final_sda_base (output_bfd, info, &gp, FALSE);
5751 if (r != bfd_reloc_ok)
5752 {
5753 _bfd_error_handler
5754 (_("%pB: warning: relocate SDA_BASE failed"), input_bfd);
5755 ret = FALSE;
5756 goto check_reloc;
5757 }
5758
5759 /* At this point `relocation' contains the object's
5760 address. */
5761 if (r_type == R_NDS32_SDA_FP7U2_RELA)
5762 {
5763 relocation -= fpbase_addr;
5764 }
5765 else
5766 relocation -= gp;
5767 /* Now it contains the offset from _SDA_BASE_. */
5768
5769 /* Make sure alignment is correct. */
5770
5771 if (relocation & align)
5772 {
5773 /* Incorrect alignment. */
5774 _bfd_error_handler
5775 /* xgettext:c-format */
5776 (_("%pB(%pA): warning: unaligned small data access"
5777 " of type %d"),
5778 input_bfd, input_section, r_type);
5779 ret = FALSE;
5780 goto check_reloc;
5781 }
5782 break;
5783
5784 case R_NDS32_17IFC_PCREL_RELA:
5785 case R_NDS32_10IFCU_PCREL_RELA:
5786 /* Do nothing. */
5787 break;
5788
5789 case R_NDS32_TLS_LE_HI20:
5790 case R_NDS32_TLS_LE_LO12:
5791 case R_NDS32_TLS_LE_20:
5792 case R_NDS32_TLS_LE_15S0:
5793 case R_NDS32_TLS_LE_15S1:
5794 case R_NDS32_TLS_LE_15S2:
5795 /* We do not have garbage collection for got entries.
5796 Therefore, IE to LE may have one empty entry, and DESC to
5797 LE may have two. */
5798 if (elf_hash_table (info)->tls_sec != NULL)
5799 relocation -= (elf_hash_table (info)->tls_sec->vma + TP_OFFSET);
5800 break;
5801
5802 case R_NDS32_TLS_IE_HI20:
5803 case R_NDS32_TLS_IE_LO12S2:
5804 case R_NDS32_TLS_DESC_HI20:
5805 case R_NDS32_TLS_DESC_LO12:
5806 case R_NDS32_TLS_IE_LO12:
5807 case R_NDS32_TLS_IEGP_HI20:
5808 case R_NDS32_TLS_IEGP_LO12:
5809 case R_NDS32_TLS_IEGP_LO12S2:
5810 {
5811 /* Relocation is to the entry for this symbol in the global
5812 offset table. */
5813 enum elf_nds32_tls_type tls_type, org_tls_type, eff_tls_type;
5814 asection *srelgot;
5815 Elf_Internal_Rela outrel;
5816 bfd_byte *loc;
5817 int indx = 0;
5818
5819 eff_tls_type = org_tls_type = get_tls_type (r_type, h);
5820
5821 BFD_ASSERT (sgot != NULL);
5822 if (h != NULL)
5823 {
5824 bfd_boolean dyn;
5825
5826 off = h->got.offset;
5827 BFD_ASSERT (off != (bfd_vma) -1);
5828 dyn = htab->root.dynamic_sections_created;
5829 tls_type = ((struct elf_nds32_link_hash_entry *) h)->tls_type;
5830 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
5831 && (!bfd_link_pic (info)
5832 || !SYMBOL_REFERENCES_LOCAL (info, h)))
5833 indx = h->dynindx;
5834 }
5835 else
5836 {
5837 BFD_ASSERT (local_got_offsets != NULL
5838 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5839 off = local_got_offsets[r_symndx];
5840 tls_type = elf32_nds32_local_got_tls_type (input_bfd)[r_symndx];
5841 }
5842
5843 relocation = sgot->output_section->vma + sgot->output_offset + off;
5844
5845 if (1 < ones32 (tls_type))
5846 {
5847 eff_tls_type = 1 << (fls (tls_type) - 1);
5848 /* TLS model shall be handled in nds32_elf_unify_tls_model (). */
5849
5850 /* TLS model X -> LE is not implement yet!
5851 workaround here! */
5852 if (eff_tls_type == GOT_TLS_LE)
5853 {
5854 eff_tls_type = 1 << (fls (tls_type ^ eff_tls_type) - 1);
5855 }
5856 }
5857
5858 /* The offset must always be a multiple of 4. We use
5859 the least significant bit to record whether we have
5860 already processed this entry. */
5861 bfd_boolean need_relocs = FALSE;
5862 srelgot = ehtab->srelgot;
5863 if ((bfd_link_pic (info) || indx != 0)
5864 && (h == NULL || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5865 || h->root.type != bfd_link_hash_undefweak))
5866 {
5867 need_relocs = TRUE;
5868 BFD_ASSERT (srelgot != NULL);
5869 }
5870
5871 if (off & 1)
5872 {
5873 off &= ~1;
5874 relocation &= ~1;
5875
5876 if (eff_tls_type & GOT_TLS_DESC)
5877 {
5878 relocation -= elf_gp (output_bfd);
5879 if ((R_NDS32_TLS_DESC_HI20 == r_type) && (!need_relocs))
5880 {
5881 /* TLS model shall be converted. */
5882 BFD_ASSERT(0);
5883 }
5884 }
5885 else if (eff_tls_type & GOT_TLS_IEGP)
5886 {
5887 relocation -= elf_gp (output_bfd);
5888 }
5889 }
5890 else
5891 {
5892 if ((eff_tls_type & GOT_TLS_LE) && (tls_type ^ eff_tls_type))
5893 {
5894 /* TLS model workaround shall be applied. */
5895 BFD_ASSERT(0);
5896 }
5897 else if (eff_tls_type & (GOT_TLS_IE | GOT_TLS_IEGP))
5898 {
5899 if (eff_tls_type & GOT_TLS_IEGP)
5900 relocation -= elf_gp(output_bfd);
5901
5902 if (need_relocs)
5903 {
5904 if (indx == 0)
5905 outrel.r_addend = gottpoff (info, relocation_sym);
5906 else
5907 outrel.r_addend = 0;
5908 outrel.r_offset = (sgot->output_section->vma
5909 + sgot->output_offset + off);
5910 outrel.r_info = ELF32_R_INFO (indx, R_NDS32_TLS_TPOFF);
5911
5912 elf32_nds32_add_dynreloc (output_bfd, info, srelgot,
5913 &outrel);
5914 }
5915 else
5916 {
5917 bfd_put_32 (output_bfd, gottpoff (info, relocation_sym),
5918 sgot->contents + off);
5919 }
5920 }
5921 else if (eff_tls_type & GOT_TLS_DESC)
5922 {
5923 relocation -= elf_gp (output_bfd);
5924 if (need_relocs)
5925 {
5926 if (indx == 0)
5927 outrel.r_addend = gottpoff (info, relocation_sym);
5928 else
5929 outrel.r_addend = 0;
5930 outrel.r_offset = (sgot->output_section->vma
5931 + sgot->output_offset + off);
5932 outrel.r_info = ELF32_R_INFO (indx, R_NDS32_TLS_DESC);
5933
5934 if (htab->tls_desc_trampoline)
5935 {
5936 asection *srelplt;
5937 srelplt = ehtab->srelplt;
5938 loc = srelplt->contents;
5939 loc += htab->next_tls_desc_index++ * sizeof (Elf32_External_Rela);
5940 BFD_ASSERT (loc + sizeof (Elf32_External_Rela)
5941 <= srelplt->contents + srelplt->size);
5942
5943 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5944 }
5945 else
5946 {
5947 loc = srelgot->contents;
5948 loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
5949 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5950 ++srelgot->reloc_count;
5951 }
5952 }
5953 else
5954 {
5955 /* feed me! */
5956 bfd_put_32 (output_bfd, 0xdeadbeef,
5957 sgot->contents + off);
5958 bfd_put_32 (output_bfd, gottpoff (info, relocation_sym),
5959 sgot->contents + off + 4);
5960 patch_tls_desc_to_ie (contents, rel, input_bfd);
5961 BFD_ASSERT(0);
5962 }
5963 }
5964 else
5965 {
5966 /* TLS model workaround shall be applied. */
5967 BFD_ASSERT(0);
5968 }
5969
5970 if (h != NULL)
5971 h->got.offset |= 1;
5972 else
5973 local_got_offsets[r_symndx] |= 1;
5974 }
5975 }
5976 break;
5977 /* DON'T fall through. */
5978
5979 default:
5980 /* OLD_NDS32_RELOC. */
5981
5982 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5983 contents, offset, relocation, addend);
5984 goto check_reloc;
5985 }
5986
5987 switch ((int) r_type)
5988 {
5989 case R_NDS32_20_RELA:
5990 case R_NDS32_5_RELA:
5991 case R_NDS32_9_PCREL_RELA:
5992 case R_NDS32_WORD_9_PCREL_RELA:
5993 case R_NDS32_10_UPCREL_RELA:
5994 case R_NDS32_15_PCREL_RELA:
5995 case R_NDS32_17_PCREL_RELA:
5996 case R_NDS32_25_PCREL_RELA:
5997 case R_NDS32_25_ABS_RELA:
5998 case R_NDS32_HI20_RELA:
5999 case R_NDS32_LO12S3_RELA:
6000 case R_NDS32_LO12S2_RELA:
6001 case R_NDS32_LO12S2_DP_RELA:
6002 case R_NDS32_LO12S2_SP_RELA:
6003 case R_NDS32_LO12S1_RELA:
6004 case R_NDS32_LO12S0_RELA:
6005 case R_NDS32_LO12S0_ORI_RELA:
6006 case R_NDS32_SDA16S3_RELA:
6007 case R_NDS32_SDA17S2_RELA:
6008 case R_NDS32_SDA18S1_RELA:
6009 case R_NDS32_SDA19S0_RELA:
6010 case R_NDS32_SDA15S3_RELA:
6011 case R_NDS32_SDA15S2_RELA:
6012 case R_NDS32_SDA12S2_DP_RELA:
6013 case R_NDS32_SDA12S2_SP_RELA:
6014 case R_NDS32_SDA15S1_RELA:
6015 case R_NDS32_SDA15S0_RELA:
6016 case R_NDS32_SDA_FP7U2_RELA:
6017 case R_NDS32_9_PLTREL:
6018 case R_NDS32_25_PLTREL:
6019 case R_NDS32_GOT20:
6020 case R_NDS32_GOT_HI20:
6021 case R_NDS32_GOT_LO12:
6022 case R_NDS32_GOT_LO15:
6023 case R_NDS32_GOT_LO19:
6024 case R_NDS32_GOT15S2_RELA:
6025 case R_NDS32_GOT17S2_RELA:
6026 case R_NDS32_GOTPC20:
6027 case R_NDS32_GOTPC_HI20:
6028 case R_NDS32_GOTPC_LO12:
6029 case R_NDS32_GOTOFF:
6030 case R_NDS32_GOTOFF_HI20:
6031 case R_NDS32_GOTOFF_LO12:
6032 case R_NDS32_GOTOFF_LO15:
6033 case R_NDS32_GOTOFF_LO19:
6034 case R_NDS32_PLTREL_HI20:
6035 case R_NDS32_PLTREL_LO12:
6036 case R_NDS32_PLT_GOTREL_HI20:
6037 case R_NDS32_PLT_GOTREL_LO12:
6038 case R_NDS32_PLT_GOTREL_LO15:
6039 case R_NDS32_PLT_GOTREL_LO19:
6040 case R_NDS32_PLT_GOTREL_LO20:
6041 case R_NDS32_17IFC_PCREL_RELA:
6042 case R_NDS32_10IFCU_PCREL_RELA:
6043 case R_NDS32_TLS_LE_HI20:
6044 case R_NDS32_TLS_LE_LO12:
6045 case R_NDS32_TLS_IE_HI20:
6046 case R_NDS32_TLS_IE_LO12S2:
6047 case R_NDS32_TLS_LE_20:
6048 case R_NDS32_TLS_LE_15S0:
6049 case R_NDS32_TLS_LE_15S1:
6050 case R_NDS32_TLS_LE_15S2:
6051 case R_NDS32_TLS_DESC_HI20:
6052 case R_NDS32_TLS_DESC_LO12:
6053 case R_NDS32_TLS_IE_LO12:
6054 case R_NDS32_TLS_IEGP_HI20:
6055 case R_NDS32_TLS_IEGP_LO12:
6056 case R_NDS32_TLS_IEGP_LO12S2:
6057 /* Instruction related relocs must handle endian properly. */
6058 /* NOTE: PIC IS NOT HANDLE YET; DO IT LATER. */
6059 r = nds32_elf_final_link_relocate (howto, input_bfd,
6060 input_section, contents,
6061 rel->r_offset, relocation,
6062 rel->r_addend);
6063 break;
6064
6065 default:
6066 /* All other relocs can use default handler. */
6067 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
6068 contents, rel->r_offset,
6069 relocation, rel->r_addend);
6070 break;
6071 }
6072
6073 check_reloc:
6074
6075 if (r != bfd_reloc_ok)
6076 {
6077 /* FIXME: This should be generic enough to go in a utility. */
6078 const char *name;
6079
6080 if (h != NULL)
6081 name = h->root.root.string;
6082 else
6083 {
6084 name = bfd_elf_string_from_elf_section
6085 (input_bfd, symtab_hdr->sh_link, sym->st_name);
6086 if (name == NULL || *name == '\0')
6087 name = bfd_section_name (sec);
6088 }
6089
6090 if (errmsg != NULL)
6091 goto common_error;
6092
6093 switch (r)
6094 {
6095 case bfd_reloc_overflow:
6096 (*info->callbacks->reloc_overflow)
6097 (info, (h ? &h->root : NULL), name, howto->name,
6098 (bfd_vma) 0, input_bfd, input_section, offset);
6099 break;
6100
6101 case bfd_reloc_undefined:
6102 (*info->callbacks->undefined_symbol)
6103 (info, name, input_bfd, input_section, offset, TRUE);
6104 break;
6105
6106 case bfd_reloc_outofrange:
6107 errmsg = _("internal error: out of range error");
6108 goto common_error;
6109
6110 case bfd_reloc_notsupported:
6111 errmsg = _("internal error: unsupported relocation error");
6112 goto common_error;
6113
6114 case bfd_reloc_dangerous:
6115 errmsg = _("internal error: dangerous error");
6116 goto common_error;
6117
6118 default:
6119 errmsg = _("internal error: unknown error");
6120 /* Fall through. */
6121
6122 common_error:
6123 (*info->callbacks->warning) (info, errmsg, name, input_bfd,
6124 input_section, offset);
6125 break;
6126 }
6127 }
6128 }
6129
6130 /* Resotre header size to avoid overflow load. */
6131 if (elf_nds32_tdata (input_bfd)->hdr_size != 0)
6132 symtab_hdr->sh_size = elf_nds32_tdata (input_bfd)->hdr_size;
6133
6134 return ret;
6135 }
6136
6137 /* Finish up dynamic symbol handling. We set the contents of various
6138 dynamic sections here. */
6139
6140 static bfd_boolean
6141 nds32_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
6142 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)
6143 {
6144 struct elf_link_hash_table *ehtab;
6145 struct elf_nds32_link_hash_entry *hent;
6146 bfd_byte *loc;
6147
6148 ehtab = elf_hash_table (info);
6149 hent = (struct elf_nds32_link_hash_entry *) h;
6150
6151 if (h->plt.offset != (bfd_vma) - 1)
6152 {
6153 asection *splt;
6154 asection *sgot;
6155 asection *srela;
6156
6157 bfd_vma plt_index;
6158 bfd_vma got_offset;
6159 bfd_vma local_plt_offset;
6160 Elf_Internal_Rela rela;
6161
6162 /* This symbol has an entry in the procedure linkage table. Set
6163 it up. */
6164
6165 BFD_ASSERT (h->dynindx != -1);
6166
6167 splt = ehtab->splt;
6168 sgot = ehtab->sgotplt;
6169 srela = ehtab->srelplt;
6170 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
6171
6172 /* Get the index in the procedure linkage table which
6173 corresponds to this symbol. This is the index of this symbol
6174 in all the symbols for which we are making plt entries. The
6175 first entry in the procedure linkage table is reserved. */
6176 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
6177
6178 /* Get the offset into the .got table of the entry that
6179 corresponds to this function. Each .got entry is 4 bytes.
6180 The first three are reserved. */
6181 got_offset = (plt_index + 3) * 4;
6182
6183 /* Fill in the entry in the procedure linkage table. */
6184 if (!bfd_link_pic (info))
6185 {
6186 unsigned long insn;
6187
6188 insn = PLT_ENTRY_WORD0 + (((sgot->output_section->vma
6189 + sgot->output_offset + got_offset) >> 12)
6190 & 0xfffff);
6191 bfd_putb32 (insn, splt->contents + h->plt.offset);
6192
6193 insn = PLT_ENTRY_WORD1 + (((sgot->output_section->vma
6194 + sgot->output_offset + got_offset) & 0x0fff)
6195 >> 2);
6196 bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
6197
6198 insn = PLT_ENTRY_WORD2;
6199 bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
6200
6201 insn = PLT_ENTRY_WORD3 + (plt_index & 0x7ffff);
6202 bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
6203
6204 insn = PLT_ENTRY_WORD4
6205 + (((unsigned int) ((-(h->plt.offset + 16)) >> 1)) & 0xffffff);
6206 bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
6207 local_plt_offset = 12;
6208 }
6209 else
6210 {
6211 /* sda_base must be set at this time. */
6212 unsigned long insn;
6213 long offset;
6214
6215 offset = sgot->output_section->vma + sgot->output_offset + got_offset
6216 - elf_gp (output_bfd);
6217 insn = PLT_PIC_ENTRY_WORD0 + ((offset >> 12) & 0xfffff);
6218 bfd_putb32 (insn, splt->contents + h->plt.offset);
6219
6220 insn = PLT_PIC_ENTRY_WORD1 + (offset & 0xfff);
6221 bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
6222
6223 insn = PLT_PIC_ENTRY_WORD2;
6224 bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
6225
6226 insn = PLT_PIC_ENTRY_WORD3;
6227 bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
6228
6229 insn = PLT_PIC_ENTRY_WORD4 + (plt_index & 0x7fffff);
6230 bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
6231
6232 insn = PLT_PIC_ENTRY_WORD5
6233 + (((unsigned int) ((-(h->plt.offset + 20)) >> 1)) & 0xffffff);
6234 bfd_putb32 (insn, splt->contents + h->plt.offset + 20);
6235
6236 local_plt_offset = 16;
6237 }
6238
6239 /* Fill in the entry in the global offset table,
6240 so it will fall through to the next instruction for the first time. */
6241 bfd_put_32 (output_bfd,
6242 (splt->output_section->vma + splt->output_offset
6243 + h->plt.offset + local_plt_offset),
6244 sgot->contents + got_offset);
6245
6246 /* Fill in the entry in the .rela.plt section. */
6247 rela.r_offset = (sgot->output_section->vma
6248 + sgot->output_offset + got_offset);
6249 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_JMP_SLOT);
6250 rela.r_addend = 0;
6251 loc = srela->contents;
6252 loc += plt_index * sizeof (Elf32_External_Rela);
6253 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
6254
6255 if (!h->def_regular)
6256 {
6257 /* Mark the symbol as undefined, rather than as defined in
6258 the .plt section. Leave the value alone. */
6259 sym->st_shndx = SHN_UNDEF;
6260 if (!h->ref_regular_nonweak)
6261 sym->st_value = 0;
6262 }
6263 }
6264
6265 if (h->got.offset != (bfd_vma) - 1
6266 && hent->tls_type == GOT_NORMAL)
6267 {
6268 asection *sgot;
6269 asection *srelagot;
6270 Elf_Internal_Rela rela;
6271
6272 /* This symbol has an entry in the global offset table.
6273 Set it up. */
6274
6275 sgot = ehtab->sgot;
6276 srelagot = ehtab->srelgot;
6277 BFD_ASSERT (sgot != NULL && srelagot != NULL);
6278
6279 rela.r_offset = (sgot->output_section->vma
6280 + sgot->output_offset + (h->got.offset & ~1));
6281
6282 /* If this is a -Bsymbolic link, and the symbol is defined
6283 locally, we just want to emit a RELATIVE reloc. Likewise if
6284 the symbol was forced to be local because of a version file.
6285 The entry in the global offset table will already have been
6286 initialized in the relocate_section function. */
6287 if ((bfd_link_pic (info)
6288 && (info->symbolic || h->dynindx == -1 || h->forced_local)
6289 && h->def_regular)
6290 || (bfd_link_pie (info) && h->def_regular))
6291 {
6292 rela.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
6293 rela.r_addend = (h->root.u.def.value
6294 + h->root.u.def.section->output_section->vma
6295 + h->root.u.def.section->output_offset);
6296
6297 if ((h->got.offset & 1) == 0)
6298 {
6299 bfd_put_32 (output_bfd, rela.r_addend,
6300 sgot->contents + h->got.offset);
6301 }
6302 }
6303 else
6304 {
6305 BFD_ASSERT ((h->got.offset & 1) == 0);
6306 bfd_put_32 (output_bfd, (bfd_vma) 0,
6307 sgot->contents + h->got.offset);
6308 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_GLOB_DAT);
6309 rela.r_addend = 0;
6310 }
6311
6312 loc = srelagot->contents;
6313 loc += srelagot->reloc_count * sizeof (Elf32_External_Rela);
6314 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
6315 ++srelagot->reloc_count;
6316 BFD_ASSERT (loc < (srelagot->contents + srelagot->size));
6317 }
6318
6319 if (h->needs_copy)
6320 {
6321 asection *s;
6322 Elf_Internal_Rela rela;
6323
6324 /* This symbols needs a copy reloc. Set it up. */
6325
6326 BFD_ASSERT (h->dynindx != -1
6327 && (h->root.type == bfd_link_hash_defined
6328 || h->root.type == bfd_link_hash_defweak));
6329
6330 s = bfd_get_section_by_name (h->root.u.def.section->owner, ".rela.bss");
6331 BFD_ASSERT (s != NULL);
6332
6333 rela.r_offset = (h->root.u.def.value
6334 + h->root.u.def.section->output_section->vma
6335 + h->root.u.def.section->output_offset);
6336 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_COPY);
6337 rela.r_addend = 0;
6338 loc = s->contents;
6339 loc += s->reloc_count * sizeof (Elf32_External_Rela);
6340 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
6341 ++s->reloc_count;
6342 }
6343
6344 /* Mark some specially defined symbols as absolute. */
6345 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
6346 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
6347 sym->st_shndx = SHN_ABS;
6348
6349 return TRUE;
6350 }
6351
6352
6353 /* Finish up the dynamic sections. */
6354
6355 static bfd_boolean
6356 nds32_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
6357 {
6358 bfd *dynobj;
6359 asection *sdyn;
6360 asection *sgotplt;
6361 struct elf_link_hash_table *ehtab;
6362 struct elf_nds32_link_hash_table *htab;
6363
6364 ehtab = elf_hash_table (info);
6365 htab = nds32_elf_hash_table (info);
6366 if (htab == NULL)
6367 return FALSE;
6368
6369 dynobj = elf_hash_table (info)->dynobj;
6370
6371 sgotplt = ehtab->sgotplt;
6372 /* A broken linker script might have discarded the dynamic sections.
6373 Catch this here so that we do not seg-fault later on. */
6374 if (sgotplt != NULL && bfd_is_abs_section (sgotplt->output_section))
6375 return FALSE;
6376 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
6377
6378 if (elf_hash_table (info)->dynamic_sections_created)
6379 {
6380 asection *splt;
6381 Elf32_External_Dyn *dyncon, *dynconend;
6382
6383 BFD_ASSERT (sgotplt != NULL && sdyn != NULL);
6384
6385 dyncon = (Elf32_External_Dyn *) sdyn->contents;
6386 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
6387
6388 for (; dyncon < dynconend; dyncon++)
6389 {
6390 Elf_Internal_Dyn dyn;
6391 asection *s;
6392
6393 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
6394
6395 switch (dyn.d_tag)
6396 {
6397 default:
6398 break;
6399
6400 case DT_PLTGOT:
6401 /* name = ".got"; */
6402 s = ehtab->sgot->output_section;
6403 goto get_vma;
6404 case DT_JMPREL:
6405 s = ehtab->srelplt->output_section;
6406 get_vma:
6407 BFD_ASSERT (s != NULL);
6408 dyn.d_un.d_ptr = s->vma;
6409 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6410 break;
6411
6412 case DT_PLTRELSZ:
6413 s = ehtab->srelplt->output_section;
6414 BFD_ASSERT (s != NULL);
6415 dyn.d_un.d_val = s->size;
6416 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6417 break;
6418
6419 case DT_RELASZ:
6420 /* My reading of the SVR4 ABI indicates that the
6421 procedure linkage table relocs (DT_JMPREL) should be
6422 included in the overall relocs (DT_RELA). This is
6423 what Solaris does. However, UnixWare can not handle
6424 that case. Therefore, we override the DT_RELASZ entry
6425 here to make it not include the JMPREL relocs. Since
6426 the linker script arranges for .rela.plt to follow all
6427 other relocation sections, we don't have to worry
6428 about changing the DT_RELA entry. */
6429 if (ehtab->srelplt != NULL)
6430 {
6431 s = ehtab->srelplt->output_section;
6432 dyn.d_un.d_val -= s->size;
6433 }
6434 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6435 break;
6436
6437 case DT_TLSDESC_PLT:
6438 s = htab->root.splt;
6439 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
6440 + htab->root.tlsdesc_plt);
6441 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6442 break;
6443
6444 case DT_TLSDESC_GOT:
6445 s = htab->root.sgot;
6446 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
6447 + htab->root.tlsdesc_got);
6448 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6449 break;
6450 }
6451 }
6452
6453 /* Fill in the first entry in the procedure linkage table. */
6454 splt = ehtab->splt;
6455 if (splt && splt->size > 0)
6456 {
6457 if (bfd_link_pic (info))
6458 {
6459 unsigned long insn;
6460 long offset;
6461
6462 offset = sgotplt->output_section->vma + sgotplt->output_offset + 4
6463 - elf_gp (output_bfd);
6464 insn = PLT0_PIC_ENTRY_WORD0 | ((offset >> 12) & 0xfffff);
6465 bfd_putb32 (insn, splt->contents);
6466
6467 /* here has a typo? */
6468 insn = PLT0_PIC_ENTRY_WORD1 | (offset & 0xfff);
6469 bfd_putb32 (insn, splt->contents + 4);
6470
6471 insn = PLT0_PIC_ENTRY_WORD2;
6472 bfd_putb32 (insn, splt->contents + 8);
6473
6474 insn = PLT0_PIC_ENTRY_WORD3;
6475 bfd_putb32 (insn, splt->contents + 12);
6476
6477 insn = PLT0_PIC_ENTRY_WORD4;
6478 bfd_putb32 (insn, splt->contents + 16);
6479
6480 insn = PLT0_PIC_ENTRY_WORD5;
6481 bfd_putb32 (insn, splt->contents + 20);
6482 }
6483 else
6484 {
6485 unsigned long insn;
6486 unsigned long addr;
6487
6488 /* addr = .got + 4 */
6489 addr = sgotplt->output_section->vma + sgotplt->output_offset + 4;
6490 insn = PLT0_ENTRY_WORD0 | ((addr >> 12) & 0xfffff);
6491 bfd_putb32 (insn, splt->contents);
6492
6493 insn = PLT0_ENTRY_WORD1 | (addr & 0x0fff);
6494 bfd_putb32 (insn, splt->contents + 4);
6495
6496 insn = PLT0_ENTRY_WORD2;
6497 bfd_putb32 (insn, splt->contents + 8);
6498
6499 insn = PLT0_ENTRY_WORD3;
6500 bfd_putb32 (insn, splt->contents + 12);
6501
6502 insn = PLT0_ENTRY_WORD4;
6503 bfd_putb32 (insn, splt->contents + 16);
6504 }
6505
6506 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
6507 PLT_ENTRY_SIZE;
6508 }
6509
6510 if (htab->root.tlsdesc_plt)
6511 {
6512 /* Calculate addresses. */
6513 asection *sgot = sgot = ehtab->sgot;
6514 bfd_vma pltgot = sgotplt->output_section->vma
6515 + sgotplt->output_offset;
6516 bfd_vma tlsdesc_got = sgot->output_section->vma + sgot->output_offset
6517 + htab->root.tlsdesc_got;
6518
6519 /* Get GP offset. */
6520 pltgot -= elf_gp (output_bfd) - 4; /* PLTGOT[1] */
6521 tlsdesc_got -= elf_gp (output_bfd);
6522
6523 /* Do relocation. */
6524 dl_tlsdesc_lazy_trampoline[0] += ((1 << 20) - 1) & (tlsdesc_got >> 12);
6525 dl_tlsdesc_lazy_trampoline[1] += 0xfff & tlsdesc_got;
6526 dl_tlsdesc_lazy_trampoline[4] += ((1 << 20) - 1) & (pltgot >> 12);
6527 dl_tlsdesc_lazy_trampoline[5] += 0xfff & pltgot;
6528
6529 /* Insert .plt. */
6530 nds32_put_trampoline (splt->contents + htab->root.tlsdesc_plt,
6531 dl_tlsdesc_lazy_trampoline,
6532 ARRAY_SIZE (dl_tlsdesc_lazy_trampoline));
6533 }
6534 }
6535
6536 /* Fill in the first three entries in the global offset table. */
6537 if (sgotplt && sgotplt->size > 0)
6538 {
6539 if (sdyn == NULL)
6540 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
6541 else
6542 bfd_put_32 (output_bfd,
6543 sdyn->output_section->vma + sdyn->output_offset,
6544 sgotplt->contents);
6545 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
6546 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
6547
6548 elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
6549 }
6550
6551 return TRUE;
6552 }
6553 \f
6554
6555 /* Set the right machine number. */
6556
6557 static bfd_boolean
6558 nds32_elf_object_p (bfd *abfd)
6559 {
6560 static unsigned int cur_arch = 0;
6561
6562 if (E_N1_ARCH != (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH))
6563 {
6564 /* E_N1_ARCH is a wild card, so it is set only when no others exist. */
6565 cur_arch = (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH);
6566 }
6567
6568 switch (cur_arch)
6569 {
6570 default:
6571 case E_N1_ARCH:
6572 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1);
6573 break;
6574 case E_N1H_ARCH:
6575 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h);
6576 break;
6577 case E_NDS_ARCH_STAR_V2_0:
6578 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v2);
6579 break;
6580 case E_NDS_ARCH_STAR_V3_0:
6581 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3);
6582 break;
6583 case E_NDS_ARCH_STAR_V3_M:
6584 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3m);
6585 break;
6586 }
6587
6588 return TRUE;
6589 }
6590
6591 /* Store the machine number in the flags field. */
6592
6593 static bfd_boolean
6594 nds32_elf_final_write_processing (bfd *abfd)
6595 {
6596 unsigned long val;
6597 static unsigned int cur_mach = 0;
6598
6599 if (bfd_mach_n1 != bfd_get_mach (abfd))
6600 {
6601 cur_mach = bfd_get_mach (abfd);
6602 }
6603
6604 switch (cur_mach)
6605 {
6606 case bfd_mach_n1:
6607 /* Only happen when object is empty, since the case is abandon. */
6608 val = E_N1_ARCH;
6609 val |= E_NDS_ABI_AABI;
6610 val |= E_NDS32_ELF_VER_1_4;
6611 break;
6612 case bfd_mach_n1h:
6613 val = E_N1H_ARCH;
6614 break;
6615 case bfd_mach_n1h_v2:
6616 val = E_NDS_ARCH_STAR_V2_0;
6617 break;
6618 case bfd_mach_n1h_v3:
6619 val = E_NDS_ARCH_STAR_V3_0;
6620 break;
6621 case bfd_mach_n1h_v3m:
6622 val = E_NDS_ARCH_STAR_V3_M;
6623 break;
6624 default:
6625 val = 0;
6626 break;
6627 }
6628
6629 elf_elfheader (abfd)->e_flags &= ~EF_NDS_ARCH;
6630 elf_elfheader (abfd)->e_flags |= val;
6631 return _bfd_elf_final_write_processing (abfd);
6632 }
6633
6634 /* Function to keep NDS32 specific file flags. */
6635
6636 static bfd_boolean
6637 nds32_elf_set_private_flags (bfd *abfd, flagword flags)
6638 {
6639 BFD_ASSERT (!elf_flags_init (abfd)
6640 || elf_elfheader (abfd)->e_flags == flags);
6641
6642 elf_elfheader (abfd)->e_flags = flags;
6643 elf_flags_init (abfd) = TRUE;
6644 return TRUE;
6645 }
6646
6647 static unsigned int
6648 convert_e_flags (unsigned int e_flags, unsigned int arch)
6649 {
6650 if ((e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9)
6651 {
6652 /* From 0.9 to 1.0. */
6653 e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V1_0;
6654
6655 /* Invert E_NDS32_HAS_NO_MAC_INST. */
6656 e_flags ^= E_NDS32_HAS_NO_MAC_INST;
6657 if (arch == E_NDS_ARCH_STAR_V1_0)
6658 {
6659 /* Done. */
6660 return e_flags;
6661 }
6662 }
6663
6664 /* From 1.0 to 2.0. */
6665 e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V2_0;
6666
6667 /* Clear E_NDS32_HAS_MFUSR_PC_INST. */
6668 e_flags &= ~E_NDS32_HAS_MFUSR_PC_INST;
6669
6670 /* Invert E_NDS32_HAS_NO_MAC_INST. */
6671 e_flags ^= E_NDS32_HAS_NO_MAC_INST;
6672 return e_flags;
6673 }
6674
6675 static bfd_boolean
6676 nds32_check_vec_size (bfd *ibfd)
6677 {
6678 static unsigned int nds32_vec_size = 0;
6679
6680 asection *sec_t = NULL;
6681 bfd_byte *contents = NULL;
6682
6683 sec_t = bfd_get_section_by_name (ibfd, ".nds32_e_flags");
6684
6685 if (sec_t && sec_t->size >= 4)
6686 {
6687 /* Get vec_size in file. */
6688 unsigned int flag_t;
6689
6690 nds32_get_section_contents (ibfd, sec_t, &contents, TRUE);
6691 flag_t = bfd_get_32 (ibfd, contents);
6692
6693 /* The value could only be 4 or 16. */
6694
6695 if (!nds32_vec_size)
6696 /* Set if not set yet. */
6697 nds32_vec_size = (flag_t & 0x3);
6698 else if (nds32_vec_size != (flag_t & 0x3))
6699 {
6700 _bfd_error_handler
6701 /* xgettext:c-format */
6702 (_("%pB: ISR vector size mismatch"
6703 " with previous modules, previous %u-byte, current %u-byte"),
6704 ibfd,
6705 nds32_vec_size == 1 ? 4 : nds32_vec_size == 2 ? 16 : 0xffffffff,
6706 (flag_t & 0x3) == 1 ? 4 : (flag_t & 0x3) == 2 ? 16 : 0xffffffff);
6707 return FALSE;
6708 }
6709 else
6710 /* Only keep the first vec_size section. */
6711 sec_t->flags |= SEC_EXCLUDE;
6712 }
6713
6714 return TRUE;
6715 }
6716
6717 /* Merge backend specific data from an object file to the output
6718 object file when linking. */
6719
6720 static bfd_boolean
6721 nds32_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6722 {
6723 bfd *obfd = info->output_bfd;
6724 flagword out_flags;
6725 flagword in_flags;
6726 flagword out_16regs;
6727 flagword in_no_mac;
6728 flagword out_no_mac;
6729 flagword in_16regs;
6730 flagword out_version;
6731 flagword in_version;
6732 flagword out_fpu_config;
6733 flagword in_fpu_config;
6734
6735 /* FIXME: What should be checked when linking shared libraries? */
6736 if ((ibfd->flags & DYNAMIC) != 0)
6737 return TRUE;
6738
6739 /* TODO: Revise to use object-attributes instead. */
6740 if (!nds32_check_vec_size (ibfd))
6741 return FALSE;
6742
6743 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6744 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6745 return TRUE;
6746
6747 if (bfd_little_endian (ibfd) != bfd_little_endian (obfd))
6748 {
6749 _bfd_error_handler
6750 (_("%pB: warning: endian mismatch with previous modules"), ibfd);
6751
6752 bfd_set_error (bfd_error_bad_value);
6753 return FALSE;
6754 }
6755
6756 /* -B option in objcopy cannot work as expected. e_flags = 0 shall be
6757 treat as generic one without checking and merging. */
6758 if (elf_elfheader (ibfd)->e_flags)
6759 {
6760 in_version = elf_elfheader (ibfd)->e_flags & EF_NDS32_ELF_VERSION;
6761 if (in_version == E_NDS32_ELF_VER_1_2)
6762 {
6763 _bfd_error_handler
6764 (_("%pB: warning: older version of object file encountered, "
6765 "please recompile with current tool chain"), ibfd);
6766 }
6767
6768 /* We may need to merge V1 and V2 arch object files to V2. */
6769 if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6770 != (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6771 {
6772 /* Need to convert version. */
6773 if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6774 == E_NDS_ARCH_STAR_RESERVED)
6775 {
6776 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6777 }
6778 else if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6779 == E_NDS_ARCH_STAR_V3_M
6780 && (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH)
6781 == E_NDS_ARCH_STAR_V3_0)
6782 {
6783 elf_elfheader (ibfd)->e_flags =
6784 (elf_elfheader (ibfd)->e_flags & (~EF_NDS_ARCH))
6785 | E_NDS_ARCH_STAR_V3_0;
6786 }
6787 else if ((elf_elfheader (obfd)->e_flags & EF_NDS_ARCH)
6788 == E_NDS_ARCH_STAR_V0_9
6789 || (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6790 > (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6791 {
6792 elf_elfheader (obfd)->e_flags =
6793 convert_e_flags (elf_elfheader (obfd)->e_flags,
6794 (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH));
6795 }
6796 else
6797 {
6798 elf_elfheader (ibfd)->e_flags =
6799 convert_e_flags (elf_elfheader (ibfd)->e_flags,
6800 (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH));
6801 }
6802 }
6803
6804 /* Extract some flags. */
6805 in_flags = elf_elfheader (ibfd)->e_flags
6806 & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6807 | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6808
6809 /* The following flags need special treatment. */
6810 in_16regs = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6811 in_no_mac = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6812 in_fpu_config = elf_elfheader (ibfd)->e_flags & E_NDS32_FPU_REG_CONF;
6813
6814 /* Extract some flags. */
6815 out_flags = elf_elfheader (obfd)->e_flags
6816 & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6817 | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6818
6819 /* The following flags need special treatment. */
6820 out_16regs = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6821 out_no_mac = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6822 out_fpu_config = elf_elfheader (obfd)->e_flags & E_NDS32_FPU_REG_CONF;
6823 out_version = elf_elfheader (obfd)->e_flags & EF_NDS32_ELF_VERSION;
6824 if (!elf_flags_init (obfd))
6825 {
6826 /* If the input is the default architecture then do not
6827 bother setting the flags for the output architecture,
6828 instead allow future merges to do this. If no future
6829 merges ever set these flags then they will retain their
6830 unitialised values, which surprise surprise, correspond
6831 to the default values. */
6832 if (bfd_get_arch_info (ibfd)->the_default)
6833 return TRUE;
6834
6835 elf_flags_init (obfd) = TRUE;
6836 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6837
6838 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
6839 && bfd_get_arch_info (obfd)->the_default)
6840 {
6841 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
6842 bfd_get_mach (ibfd));
6843 }
6844
6845 return TRUE;
6846 }
6847
6848 /* Check flag compatibility. */
6849 if ((in_flags & EF_NDS_ABI) != (out_flags & EF_NDS_ABI))
6850 {
6851 _bfd_error_handler
6852 (_("%pB: error: ABI mismatch with previous modules"), ibfd);
6853 bfd_set_error (bfd_error_bad_value);
6854 return FALSE;
6855 }
6856
6857 if ((in_flags & EF_NDS_ARCH) != (out_flags & EF_NDS_ARCH))
6858 {
6859 if (((in_flags & EF_NDS_ARCH) != E_N1_ARCH))
6860 {
6861 _bfd_error_handler
6862 (_("%pB: error: instruction set mismatch with previous modules"),
6863 ibfd);
6864
6865 bfd_set_error (bfd_error_bad_value);
6866 return FALSE;
6867 }
6868 }
6869
6870 /* When linking with V1.2 and V1.3 objects together the output is V1.2.
6871 and perf ext1 and DIV are mergerd to perf ext1. */
6872 if (in_version == E_NDS32_ELF_VER_1_2 || out_version == E_NDS32_ELF_VER_1_2)
6873 {
6874 elf_elfheader (obfd)->e_flags =
6875 (in_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6876 | (out_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6877 | (((in_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6878 ? E_NDS32_HAS_EXT_INST : 0)
6879 | (((out_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6880 ? E_NDS32_HAS_EXT_INST : 0)
6881 | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6882 | ((in_version > out_version) ? out_version : in_version);
6883 }
6884 else
6885 {
6886 if (in_version != out_version)
6887 _bfd_error_handler
6888 /* xgettext:c-format */
6889 (_("%pB: warning: incompatible elf-versions %s and %s"),
6890 ibfd, nds32_elfver_strtab[out_version],
6891 nds32_elfver_strtab[in_version]);
6892
6893 elf_elfheader (obfd)->e_flags = in_flags | out_flags
6894 | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6895 | (in_fpu_config > out_fpu_config ? in_fpu_config : out_fpu_config)
6896 | (in_version > out_version ? out_version : in_version);
6897 }
6898 }
6899
6900 return TRUE;
6901 }
6902
6903 /* Display the flags field. */
6904
6905 static bfd_boolean
6906 nds32_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6907 {
6908 FILE *file = (FILE *) ptr;
6909
6910 BFD_ASSERT (abfd != NULL && ptr != NULL);
6911
6912 _bfd_elf_print_private_bfd_data (abfd, ptr);
6913
6914 fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
6915
6916 switch (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH)
6917 {
6918 default:
6919 case E_N1_ARCH:
6920 fprintf (file, _(": n1 instructions"));
6921 break;
6922 case E_N1H_ARCH:
6923 fprintf (file, _(": n1h instructions"));
6924 break;
6925 }
6926
6927 fputc ('\n', file);
6928
6929 return TRUE;
6930 }
6931
6932 static unsigned int
6933 nds32_elf_action_discarded (asection *sec)
6934 {
6935
6936 if (strncmp
6937 (".gcc_except_table", sec->name, sizeof (".gcc_except_table") - 1) == 0)
6938 return 0;
6939
6940 return _bfd_elf_default_action_discarded (sec);
6941 }
6942
6943 static asection *
6944 nds32_elf_gc_mark_hook (asection *sec, struct bfd_link_info *info,
6945 Elf_Internal_Rela *rel, struct elf_link_hash_entry *h,
6946 Elf_Internal_Sym *sym)
6947 {
6948 if (h != NULL)
6949 switch (ELF32_R_TYPE (rel->r_info))
6950 {
6951 case R_NDS32_GNU_VTINHERIT:
6952 case R_NDS32_GNU_VTENTRY:
6953 case R_NDS32_RELA_GNU_VTINHERIT:
6954 case R_NDS32_RELA_GNU_VTENTRY:
6955 return NULL;
6956 }
6957
6958 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6959 }
6960
6961 static enum elf_nds32_tls_type
6962 get_tls_type (enum elf_nds32_reloc_type r_type,
6963 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
6964 {
6965 enum elf_nds32_tls_type tls_type;
6966
6967 switch (r_type)
6968 {
6969 case R_NDS32_TLS_LE_HI20:
6970 case R_NDS32_TLS_LE_LO12:
6971 tls_type = GOT_TLS_LE;
6972 break;
6973 case R_NDS32_TLS_IE_HI20:
6974 case R_NDS32_TLS_IE_LO12S2:
6975 case R_NDS32_TLS_IE_LO12:
6976 tls_type = GOT_TLS_IE;
6977 break;
6978 case R_NDS32_TLS_IEGP_HI20:
6979 case R_NDS32_TLS_IEGP_LO12:
6980 case R_NDS32_TLS_IEGP_LO12S2:
6981 tls_type = GOT_TLS_IEGP;
6982 break;
6983 case R_NDS32_TLS_DESC_HI20:
6984 case R_NDS32_TLS_DESC_LO12:
6985 case R_NDS32_TLS_DESC_ADD:
6986 case R_NDS32_TLS_DESC_FUNC:
6987 case R_NDS32_TLS_DESC_CALL:
6988 tls_type = GOT_TLS_DESC;
6989 break;
6990 default:
6991 tls_type = GOT_NORMAL;
6992 break;
6993 }
6994
6995 return tls_type;
6996 }
6997
6998 /* Ensure that we have allocated bookkeeping structures for ABFD's local
6999 symbols. */
7000
7001 static bfd_boolean
7002 elf32_nds32_allocate_local_sym_info (bfd *abfd)
7003 {
7004 if (elf_local_got_refcounts (abfd) == NULL)
7005 {
7006 bfd_size_type num_syms;
7007 bfd_size_type size;
7008 char *data;
7009
7010 num_syms = elf_tdata (abfd)->symtab_hdr.sh_info;
7011 /* This space is for got_refcounts, got_tls_type, tlsdesc_gotent, and
7012 gp_offset. The details can refer to struct elf_nds32_obj_tdata. */
7013 size = num_syms * (sizeof (bfd_signed_vma) + sizeof (char)
7014 + sizeof (bfd_vma) + sizeof (int)
7015 + sizeof (bfd_boolean) + sizeof (bfd_vma));
7016 data = bfd_zalloc (abfd, size);
7017 if (data == NULL)
7018 return FALSE;
7019
7020 elf_local_got_refcounts (abfd) = (bfd_signed_vma *) data;
7021 data += num_syms * sizeof (bfd_signed_vma);
7022
7023 elf32_nds32_local_got_tls_type (abfd) = (char *) data;
7024 data += num_syms * sizeof (char);
7025
7026 elf32_nds32_local_tlsdesc_gotent (abfd) = (bfd_vma *) data;
7027 data += num_syms * sizeof (bfd_vma);
7028
7029 elf32_nds32_local_gp_offset (abfd) = (int *) data;
7030 data += num_syms * sizeof (int);
7031 }
7032
7033 return TRUE;
7034 }
7035
7036 /* Look through the relocs for a section during the first phase.
7037 Since we don't do .gots or .plts, we just need to consider the
7038 virtual table relocs for gc. */
7039
7040 static bfd_boolean
7041 nds32_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
7042 asection *sec, const Elf_Internal_Rela *relocs)
7043 {
7044 Elf_Internal_Shdr *symtab_hdr;
7045 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
7046 const Elf_Internal_Rela *rel;
7047 const Elf_Internal_Rela *rel_end;
7048 struct elf_link_hash_table *ehtab;
7049 struct elf_nds32_link_hash_table *htab;
7050 bfd *dynobj;
7051 asection *sreloc = NULL;
7052
7053 /* No need for relocation if relocatable already. */
7054 if (bfd_link_relocatable (info))
7055 {
7056 elf32_nds32_check_relax_group (abfd, sec);
7057 return TRUE;
7058 }
7059
7060 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7061 sym_hashes = elf_sym_hashes (abfd);
7062 sym_hashes_end =
7063 sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
7064 if (!elf_bad_symtab (abfd))
7065 sym_hashes_end -= symtab_hdr->sh_info;
7066
7067 ehtab = elf_hash_table (info);
7068 htab = nds32_elf_hash_table (info);
7069 dynobj = htab->root.dynobj;
7070
7071 rel_end = relocs + sec->reloc_count;
7072 for (rel = relocs; rel < rel_end; rel++)
7073 {
7074 enum elf_nds32_reloc_type r_type;
7075 struct elf_link_hash_entry *h;
7076 unsigned long r_symndx;
7077 enum elf_nds32_tls_type tls_type, old_tls_type;
7078
7079 r_symndx = ELF32_R_SYM (rel->r_info);
7080 r_type = ELF32_R_TYPE (rel->r_info);
7081 if (r_symndx < symtab_hdr->sh_info)
7082 h = NULL;
7083 else
7084 {
7085 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7086 while (h->root.type == bfd_link_hash_indirect
7087 || h->root.type == bfd_link_hash_warning)
7088 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7089 }
7090
7091 /* Create .got section if necessary.
7092 Some relocs require a global offset table. We create
7093 got section here, since these relocation need a got section
7094 and if it is not created yet. */
7095 if (ehtab->sgot == NULL)
7096 {
7097 switch (r_type)
7098 {
7099 case R_NDS32_GOT_HI20:
7100 case R_NDS32_GOT_LO12:
7101 case R_NDS32_GOT_LO15:
7102 case R_NDS32_GOT_LO19:
7103 case R_NDS32_GOT17S2_RELA:
7104 case R_NDS32_GOT15S2_RELA:
7105 case R_NDS32_GOTOFF:
7106 case R_NDS32_GOTOFF_HI20:
7107 case R_NDS32_GOTOFF_LO12:
7108 case R_NDS32_GOTOFF_LO15:
7109 case R_NDS32_GOTOFF_LO19:
7110 case R_NDS32_GOTPC20:
7111 case R_NDS32_GOTPC_HI20:
7112 case R_NDS32_GOTPC_LO12:
7113 case R_NDS32_GOT20:
7114 case R_NDS32_TLS_IE_HI20:
7115 case R_NDS32_TLS_IE_LO12:
7116 case R_NDS32_TLS_IE_LO12S2:
7117 case R_NDS32_TLS_IEGP_HI20:
7118 case R_NDS32_TLS_IEGP_LO12:
7119 case R_NDS32_TLS_IEGP_LO12S2:
7120 case R_NDS32_TLS_DESC_HI20:
7121 case R_NDS32_TLS_DESC_LO12:
7122 if (dynobj == NULL)
7123 htab->root.dynobj = dynobj = abfd;
7124 if (!create_got_section (dynobj, info))
7125 return FALSE;
7126 break;
7127
7128 default:
7129 break;
7130 }
7131 }
7132
7133 /* Check relocation type. */
7134 switch ((int) r_type)
7135 {
7136 case R_NDS32_GOT_HI20:
7137 case R_NDS32_GOT_LO12:
7138 case R_NDS32_GOT_LO15:
7139 case R_NDS32_GOT_LO19:
7140 case R_NDS32_GOT20:
7141 case R_NDS32_TLS_LE_HI20:
7142 case R_NDS32_TLS_LE_LO12:
7143 case R_NDS32_TLS_IE_HI20:
7144 case R_NDS32_TLS_IE_LO12:
7145 case R_NDS32_TLS_IE_LO12S2:
7146 case R_NDS32_TLS_IEGP_HI20:
7147 case R_NDS32_TLS_IEGP_LO12:
7148 case R_NDS32_TLS_IEGP_LO12S2:
7149 case R_NDS32_TLS_DESC_HI20:
7150 case R_NDS32_TLS_DESC_LO12:
7151 tls_type = get_tls_type (r_type, h);
7152 if (h)
7153 {
7154 if (tls_type != GOT_TLS_LE)
7155 h->got.refcount += 1;
7156 old_tls_type = elf32_nds32_hash_entry (h)->tls_type;
7157 }
7158 else
7159 {
7160 /* This is a global offset table entry for a local symbol. */
7161 if (!elf32_nds32_allocate_local_sym_info (abfd))
7162 return FALSE;
7163
7164 BFD_ASSERT (r_symndx < symtab_hdr->sh_info);
7165 if (tls_type != GOT_TLS_LE)
7166 elf_local_got_refcounts (abfd)[r_symndx] += 1;
7167 old_tls_type = elf32_nds32_local_got_tls_type (abfd)[r_symndx];
7168 }
7169
7170 /* We would already have issued an error message if there
7171 is a TLS/non-TLS mismatch, based on the symbol
7172 type. So just combine any TLS types needed. */
7173 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
7174 && tls_type != GOT_NORMAL)
7175 tls_type |= old_tls_type;
7176
7177 /* DESC to IE/IEGP if link to executable. */
7178 if ((tls_type & (GOT_TLS_DESC | GOT_TLS_IEGP))
7179 && (bfd_link_executable (info)))
7180 tls_type |= (bfd_link_pie (info) ? GOT_TLS_IEGP : GOT_TLS_IE);
7181
7182 if (old_tls_type != tls_type)
7183 {
7184 if (h != NULL)
7185 elf32_nds32_hash_entry (h)->tls_type = tls_type;
7186 else
7187 elf32_nds32_local_got_tls_type (abfd)[r_symndx] = tls_type;
7188 }
7189 break;
7190 case R_NDS32_9_PLTREL:
7191 case R_NDS32_25_PLTREL:
7192 case R_NDS32_PLTREL_HI20:
7193 case R_NDS32_PLTREL_LO12:
7194 case R_NDS32_PLT_GOTREL_HI20:
7195 case R_NDS32_PLT_GOTREL_LO12:
7196 case R_NDS32_PLT_GOTREL_LO15:
7197 case R_NDS32_PLT_GOTREL_LO19:
7198 case R_NDS32_PLT_GOTREL_LO20:
7199
7200 /* This symbol requires a procedure linkage table entry. We
7201 actually build the entry in adjust_dynamic_symbol,
7202 because this might be a case of linking PIC code without
7203 linking in any dynamic objects, in which case we don't
7204 need to generate a procedure linkage table after all. */
7205
7206 /* If this is a local symbol, we resolve it directly without
7207 creating a procedure linkage table entry. */
7208 if (h == NULL)
7209 continue;
7210
7211 if (h->forced_local
7212 || (bfd_link_pie (info) && h->def_regular))
7213 break;
7214
7215 elf32_nds32_hash_entry (h)->tls_type = GOT_NORMAL;
7216 h->needs_plt = 1;
7217 h->plt.refcount += 1;
7218 break;
7219
7220 case R_NDS32_16_RELA:
7221 case R_NDS32_20_RELA:
7222 case R_NDS32_5_RELA:
7223 case R_NDS32_32_RELA:
7224 case R_NDS32_HI20_RELA:
7225 case R_NDS32_LO12S3_RELA:
7226 case R_NDS32_LO12S2_RELA:
7227 case R_NDS32_LO12S2_DP_RELA:
7228 case R_NDS32_LO12S2_SP_RELA:
7229 case R_NDS32_LO12S1_RELA:
7230 case R_NDS32_LO12S0_RELA:
7231 case R_NDS32_LO12S0_ORI_RELA:
7232 case R_NDS32_SDA16S3_RELA:
7233 case R_NDS32_SDA17S2_RELA:
7234 case R_NDS32_SDA18S1_RELA:
7235 case R_NDS32_SDA19S0_RELA:
7236 case R_NDS32_SDA15S3_RELA:
7237 case R_NDS32_SDA15S2_RELA:
7238 case R_NDS32_SDA12S2_DP_RELA:
7239 case R_NDS32_SDA12S2_SP_RELA:
7240 case R_NDS32_SDA15S1_RELA:
7241 case R_NDS32_SDA15S0_RELA:
7242 case R_NDS32_SDA_FP7U2_RELA:
7243 case R_NDS32_15_PCREL_RELA:
7244 case R_NDS32_17_PCREL_RELA:
7245 case R_NDS32_25_PCREL_RELA:
7246
7247 if (h != NULL && !bfd_link_pic (info))
7248 {
7249 h->non_got_ref = 1;
7250 h->plt.refcount += 1;
7251 }
7252
7253 /* If we are creating a shared library, and this is a reloc against
7254 a global symbol, or a non PC relative reloc against a local
7255 symbol, then we need to copy the reloc into the shared library.
7256 However, if we are linking with -Bsymbolic, we do not need to
7257 copy a reloc against a global symbol which is defined in an
7258 object we are including in the link (i.e., DEF_REGULAR is set).
7259 At this point we have not seen all the input files, so it is
7260 possible that DEF_REGULAR is not set now but will be set later
7261 (it is never cleared). We account for that possibility below by
7262 storing information in the dyn_relocs field of the hash table
7263 entry. A similar situation occurs when creating shared libraries
7264 and symbol visibility changes render the symbol local.
7265
7266 If on the other hand, we are creating an executable, we may need
7267 to keep relocations for symbols satisfied by a dynamic library
7268 if we manage to avoid copy relocs for the symbol. */
7269 if ((bfd_link_pic (info)
7270 && (sec->flags & SEC_ALLOC) != 0
7271 && ((r_type != R_NDS32_25_PCREL_RELA
7272 && r_type != R_NDS32_15_PCREL_RELA
7273 && r_type != R_NDS32_17_PCREL_RELA
7274 && !(r_type == R_NDS32_32_RELA
7275 && strcmp (sec->name, ".eh_frame") == 0))
7276 || (h != NULL
7277 && (!info->symbolic
7278 || h->root.type == bfd_link_hash_defweak
7279 || !h->def_regular))))
7280 || (!bfd_link_pic (info)
7281 && (sec->flags & SEC_ALLOC) != 0
7282 && h != NULL
7283 && (h->root.type == bfd_link_hash_defweak
7284 || !h->def_regular)))
7285 {
7286 struct elf_dyn_relocs *p;
7287 struct elf_dyn_relocs **head;
7288
7289 if (dynobj == NULL)
7290 htab->root.dynobj = dynobj = abfd;
7291
7292 /* When creating a shared object, we must copy these
7293 relocs into the output file. We create a reloc
7294 section in dynobj and make room for the reloc. */
7295 if (sreloc == NULL)
7296 {
7297 const char *name;
7298
7299 name = bfd_elf_string_from_elf_section
7300 (abfd, elf_elfheader (abfd)->e_shstrndx,
7301 elf_section_data (sec)->rela.hdr->sh_name);
7302 if (name == NULL)
7303 return FALSE;
7304
7305 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
7306 && strcmp (bfd_section_name (sec),
7307 name + 5) == 0);
7308
7309 sreloc = bfd_get_section_by_name (dynobj, name);
7310 if (sreloc == NULL)
7311 {
7312 flagword flags;
7313
7314 sreloc = bfd_make_section (dynobj, name);
7315 flags = (SEC_HAS_CONTENTS | SEC_READONLY
7316 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
7317 if ((sec->flags & SEC_ALLOC) != 0)
7318 flags |= SEC_ALLOC | SEC_LOAD;
7319 if (sreloc == NULL
7320 || !bfd_set_section_flags (sreloc, flags)
7321 || !bfd_set_section_alignment (sreloc, 2))
7322 return FALSE;
7323
7324 elf_section_type (sreloc) = SHT_RELA;
7325 }
7326 elf_section_data (sec)->sreloc = sreloc;
7327 }
7328
7329 /* If this is a global symbol, we count the number of
7330 relocations we need for this symbol. */
7331 if (h != NULL)
7332 head = &h->dyn_relocs;
7333 else
7334 {
7335 asection *s;
7336 void *vpp;
7337
7338 Elf_Internal_Sym *isym;
7339 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx);
7340 if (isym == NULL)
7341 return FALSE;
7342
7343 /* Track dynamic relocs needed for local syms too. */
7344 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
7345 if (s == NULL)
7346 return FALSE;
7347
7348 vpp = &elf_section_data (s)->local_dynrel;
7349 head = (struct elf_dyn_relocs **) vpp;
7350 }
7351
7352 p = *head;
7353 if (p == NULL || p->sec != sec)
7354 {
7355 size_t amt = sizeof (*p);
7356 p = (struct elf_dyn_relocs *) bfd_alloc (dynobj, amt);
7357 if (p == NULL)
7358 return FALSE;
7359 p->next = *head;
7360 *head = p;
7361 p->sec = sec;
7362 p->count = 0;
7363 p->pc_count = 0;
7364 }
7365
7366 p->count += 1;
7367
7368 /* Since eh_frame is readonly, R_NDS32_32_RELA
7369 reloc for eh_frame will cause shared library has
7370 TEXTREL entry in the dynamic section. This lead glibc
7371 testsuites to failure (bug-13092) and cause kernel fail
7372 (bug-11819). I think the best solution is to replace
7373 absolute reloc with pc relative reloc in the eh_frame.
7374 To do that, we need to support the following issues:
7375
7376 === For GCC ===
7377 * gcc/config/nds32/nds32.h: Define
7378 ASM_PREFERRED_EH_DATA_FORMAT to encode DW_EH_PE_pcrel
7379 and DW_EH_PE_sdata4 into DWARF exception header when
7380 option have '-fpic'.
7381
7382 === For binutils ===
7383 * bfd/: Define new reloc R_NDS32_32_PCREL_RELA.
7384 * gas/config/tc-nds32.h: Define DIFF_EXPR_OK. This
7385 may break our nds DIFF mechanism, therefore, we
7386 must disable all linker relaxations to ensure
7387 correctness.
7388 * gas/config/tc-nds32.c (nds32_apply_fix): Replace
7389 R_NDS32_32_RELA with R_NDS32_32_PCREL_RELA, and
7390 do the necessary modification.
7391
7392 Unfortunately, it still have some problems for nds32
7393 to support pc relative reloc in the eh_frame. So I use
7394 another solution to fix this issue.
7395
7396 However, I find that ld always emit TEXTREL marker for
7397 R_NDS32_NONE relocs in rel.dyn. These none relocs are
7398 correspond to R_NDS32_32_RELA for .eh_frame section.
7399 It means that we always reserve redundant entries of rel.dyn
7400 for these relocs which actually do nothing in dynamic linker.
7401
7402 Therefore, we regard these relocs as pc relative relocs
7403 here and increase the pc_count. */
7404 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA
7405 || ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
7406 || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA
7407 || (r_type == R_NDS32_32_RELA
7408 && strcmp (sec->name, ".eh_frame") == 0))
7409 p->pc_count += 1;
7410 }
7411 break;
7412
7413 /* This relocation describes the C++ object vtable hierarchy.
7414 Reconstruct it for later use during GC. */
7415 case R_NDS32_RELA_GNU_VTINHERIT:
7416 case R_NDS32_GNU_VTINHERIT:
7417 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
7418 return FALSE;
7419 break;
7420
7421 /* This relocation describes which C++ vtable entries are actually
7422 used. Record for later use during GC. */
7423 case R_NDS32_GNU_VTENTRY:
7424 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
7425 return FALSE;
7426 break;
7427 case R_NDS32_RELA_GNU_VTENTRY:
7428 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
7429 return FALSE;
7430 break;
7431 }
7432 }
7433
7434 return TRUE;
7435 }
7436
7437 /* Write VAL in uleb128 format to P, returning a pointer to the
7438 following byte.
7439 This code is copied from elf-attr.c. */
7440
7441 static bfd_byte *
7442 write_uleb128 (bfd_byte *p, unsigned int val)
7443 {
7444 bfd_byte c;
7445 do
7446 {
7447 c = val & 0x7f;
7448 val >>= 7;
7449 if (val)
7450 c |= 0x80;
7451 *(p++) = c;
7452 }
7453 while (val);
7454 return p;
7455 }
7456
7457 static bfd_signed_vma
7458 calculate_offset (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
7459 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr)
7460 {
7461 bfd_signed_vma foff;
7462 bfd_vma symval, addend;
7463 asection *sym_sec;
7464
7465 /* Get the value of the symbol referred to by the reloc. */
7466 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
7467 {
7468 Elf_Internal_Sym *isym;
7469
7470 /* A local symbol. */
7471 isym = isymbuf + ELF32_R_SYM (irel->r_info);
7472
7473 if (isym->st_shndx == SHN_UNDEF)
7474 sym_sec = bfd_und_section_ptr;
7475 else if (isym->st_shndx == SHN_ABS)
7476 sym_sec = bfd_abs_section_ptr;
7477 else if (isym->st_shndx == SHN_COMMON)
7478 sym_sec = bfd_com_section_ptr;
7479 else
7480 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
7481 symval = isym->st_value + sym_sec->output_section->vma
7482 + sym_sec->output_offset;
7483 }
7484 else
7485 {
7486 unsigned long indx;
7487 struct elf_link_hash_entry *h;
7488
7489 /* An external symbol. */
7490 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
7491 h = elf_sym_hashes (abfd)[indx];
7492 BFD_ASSERT (h != NULL);
7493
7494 if (h->root.type != bfd_link_hash_defined
7495 && h->root.type != bfd_link_hash_defweak)
7496 /* This appears to be a reference to an undefined
7497 symbol. Just ignore it--it will be caught by the
7498 regular reloc processing. */
7499 return 0;
7500
7501 if (h->root.u.def.section->flags & SEC_MERGE)
7502 {
7503 sym_sec = h->root.u.def.section;
7504 symval = _bfd_merged_section_offset (abfd, &sym_sec,
7505 elf_section_data (sym_sec)->sec_info,
7506 h->root.u.def.value);
7507 symval = symval + sym_sec->output_section->vma
7508 + sym_sec->output_offset;
7509 }
7510 else
7511 symval = (h->root.u.def.value
7512 + h->root.u.def.section->output_section->vma
7513 + h->root.u.def.section->output_offset);
7514 }
7515
7516 addend = irel->r_addend;
7517
7518 foff = (symval + addend
7519 - (irel->r_offset + sec->output_section->vma + sec->output_offset));
7520 return foff;
7521 }
7522 \f
7523
7524 /* Convert a 32-bit instruction to 16-bit one.
7525 INSN is the input 32-bit instruction, INSN16 is the output 16-bit
7526 instruction. If INSN_TYPE is not NULL, it the CGEN instruction
7527 type of INSN16. Return 1 if successful. */
7528
7529 static int
7530 nds32_convert_32_to_16_alu1 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7531 int *pinsn_type)
7532 {
7533 uint16_t insn16 = 0;
7534 int insn_type = 0;
7535 unsigned long mach = bfd_get_mach (abfd);
7536
7537 if (N32_SH5 (insn) != 0)
7538 return 0;
7539
7540 switch (N32_SUB5 (insn))
7541 {
7542 case N32_ALU1_ADD_SLLI:
7543 case N32_ALU1_ADD_SRLI:
7544 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
7545 {
7546 insn16 = N16_TYPE333 (ADD333, N32_RT5 (insn), N32_RA5 (insn),
7547 N32_RB5 (insn));
7548 insn_type = NDS32_INSN_ADD333;
7549 }
7550 else if (N32_IS_RT4 (insn))
7551 {
7552 if (N32_RT5 (insn) == N32_RA5 (insn))
7553 insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RB5 (insn));
7554 else if (N32_RT5 (insn) == N32_RB5 (insn))
7555 insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RA5 (insn));
7556 insn_type = NDS32_INSN_ADD45;
7557 }
7558 break;
7559
7560 case N32_ALU1_SUB_SLLI:
7561 case N32_ALU1_SUB_SRLI:
7562 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
7563 {
7564 insn16 = N16_TYPE333 (SUB333, N32_RT5 (insn), N32_RA5 (insn),
7565 N32_RB5 (insn));
7566 insn_type = NDS32_INSN_SUB333;
7567 }
7568 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
7569 {
7570 insn16 = N16_TYPE45 (SUB45, N32_RT54 (insn), N32_RB5 (insn));
7571 insn_type = NDS32_INSN_SUB45;
7572 }
7573 break;
7574
7575 case N32_ALU1_AND_SLLI:
7576 case N32_ALU1_AND_SRLI:
7577 /* and $rt, $rt, $rb -> and33 for v3, v3m. */
7578 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7579 && N32_IS_RB3 (insn))
7580 {
7581 if (N32_RT5 (insn) == N32_RA5 (insn))
7582 insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RB5 (insn));
7583 else if (N32_RT5 (insn) == N32_RB5 (insn))
7584 insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RA5 (insn));
7585 if (insn16)
7586 insn_type = NDS32_INSN_AND33;
7587 }
7588 break;
7589
7590 case N32_ALU1_XOR_SLLI:
7591 case N32_ALU1_XOR_SRLI:
7592 /* xor $rt, $rt, $rb -> xor33 for v3, v3m. */
7593 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7594 && N32_IS_RB3 (insn))
7595 {
7596 if (N32_RT5 (insn) == N32_RA5 (insn))
7597 insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RB5 (insn));
7598 else if (N32_RT5 (insn) == N32_RB5 (insn))
7599 insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RA5 (insn));
7600 if (insn16)
7601 insn_type = NDS32_INSN_XOR33;
7602 }
7603 break;
7604
7605 case N32_ALU1_OR_SLLI:
7606 case N32_ALU1_OR_SRLI:
7607 /* or $rt, $rt, $rb -> or33 for v3, v3m. */
7608 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7609 && N32_IS_RB3 (insn))
7610 {
7611 if (N32_RT5 (insn) == N32_RA5 (insn))
7612 insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RB5 (insn));
7613 else if (N32_RT5 (insn) == N32_RB5 (insn))
7614 insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RA5 (insn));
7615 if (insn16)
7616 insn_type = NDS32_INSN_OR33;
7617 }
7618 break;
7619 case N32_ALU1_NOR:
7620 /* nor $rt, $ra, $ra -> not33 for v3, v3m. */
7621 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RB3 (insn)
7622 && N32_RA5 (insn) == N32_RB5 (insn))
7623 {
7624 insn16 = N16_MISC33 (NOT33, N32_RT5 (insn), N32_RA5 (insn));
7625 insn_type = NDS32_INSN_NOT33;
7626 }
7627 break;
7628 case N32_ALU1_SRAI:
7629 if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
7630 {
7631 insn16 = N16_TYPE45 (SRAI45, N32_RT54 (insn), N32_UB5 (insn));
7632 insn_type = NDS32_INSN_SRAI45;
7633 }
7634 break;
7635
7636 case N32_ALU1_SRLI:
7637 if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
7638 {
7639 insn16 = N16_TYPE45 (SRLI45, N32_RT54 (insn), N32_UB5 (insn));
7640 insn_type = NDS32_INSN_SRLI45;
7641 }
7642 break;
7643
7644 case N32_ALU1_SLLI:
7645 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_UB5 (insn) < 8)
7646 {
7647 insn16 = N16_TYPE333 (SLLI333, N32_RT5 (insn), N32_RA5 (insn),
7648 N32_UB5 (insn));
7649 insn_type = NDS32_INSN_SLLI333;
7650 }
7651 break;
7652
7653 case N32_ALU1_ZEH:
7654 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7655 {
7656 insn16 = N16_BFMI333 (ZEH33, N32_RT5 (insn), N32_RA5 (insn));
7657 insn_type = NDS32_INSN_ZEH33;
7658 }
7659 break;
7660
7661 case N32_ALU1_SEB:
7662 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7663 {
7664 insn16 = N16_BFMI333 (SEB33, N32_RT5 (insn), N32_RA5 (insn));
7665 insn_type = NDS32_INSN_SEB33;
7666 }
7667 break;
7668
7669 case N32_ALU1_SEH:
7670 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7671 {
7672 insn16 = N16_BFMI333 (SEH33, N32_RT5 (insn), N32_RA5 (insn));
7673 insn_type = NDS32_INSN_SEH33;
7674 }
7675 break;
7676
7677 case N32_ALU1_SLT:
7678 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7679 {
7680 /* Implicit r15. */
7681 insn16 = N16_TYPE45 (SLT45, N32_RA54 (insn), N32_RB5 (insn));
7682 insn_type = NDS32_INSN_SLT45;
7683 }
7684 break;
7685
7686 case N32_ALU1_SLTS:
7687 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7688 {
7689 /* Implicit r15. */
7690 insn16 = N16_TYPE45 (SLTS45, N32_RA54 (insn), N32_RB5 (insn));
7691 insn_type = NDS32_INSN_SLTS45;
7692 }
7693 break;
7694 }
7695
7696 if ((insn16 & 0x8000) == 0)
7697 return 0;
7698
7699 if (pinsn16)
7700 *pinsn16 = insn16;
7701 if (pinsn_type)
7702 *pinsn_type = insn_type;
7703 return 1;
7704 }
7705
7706 static int
7707 nds32_convert_32_to_16_alu2 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7708 int *pinsn_type)
7709 {
7710 uint16_t insn16 = 0;
7711 int insn_type;
7712 unsigned long mach = bfd_get_mach (abfd);
7713
7714 /* TODO: bset, bclr, btgl, btst. */
7715 if (__GF (insn, 6, 4) != 0)
7716 return 0;
7717
7718 switch (N32_IMMU (insn, 6))
7719 {
7720 case N32_ALU2_MUL:
7721 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7722 && N32_IS_RB3 (insn))
7723 {
7724 if (N32_RT5 (insn) == N32_RA5 (insn))
7725 insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RB5 (insn));
7726 else if (N32_RT5 (insn) == N32_RB5 (insn))
7727 insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RA5 (insn));
7728 if (insn16)
7729 insn_type = NDS32_INSN_MUL33;
7730 }
7731 }
7732
7733 if ((insn16 & 0x8000) == 0)
7734 return 0;
7735
7736 if (pinsn16)
7737 *pinsn16 = insn16;
7738 if (pinsn_type)
7739 *pinsn_type = insn_type;
7740 return 1;
7741 }
7742
7743 int
7744 nds32_convert_32_to_16 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7745 int *pinsn_type)
7746 {
7747 int op6;
7748 uint16_t insn16 = 0;
7749 int insn_type = 0;
7750 unsigned long mach = bfd_get_mach (abfd);
7751
7752 /* Decode 32-bit instruction. */
7753 if (insn & 0x80000000)
7754 {
7755 /* Not 32-bit insn. */
7756 return 0;
7757 }
7758
7759 op6 = N32_OP6 (insn);
7760
7761 /* Convert it to 16-bit instruction. */
7762 switch (op6)
7763 {
7764 case N32_OP6_MOVI:
7765 if (IS_WITHIN_S (N32_IMM20S (insn), 5))
7766 {
7767 insn16 = N16_TYPE55 (MOVI55, N32_RT5 (insn), N32_IMM20S (insn));
7768 insn_type = NDS32_INSN_MOVI55;
7769 }
7770 else if (mach >= MACH_V3 && N32_IMM20S (insn) >= 16
7771 && N32_IMM20S (insn) < 48 && N32_IS_RT4 (insn))
7772 {
7773 insn16 = N16_TYPE45 (MOVPI45, N32_RT54 (insn),
7774 N32_IMM20S (insn) - 16);
7775 insn_type = NDS32_INSN_MOVPI45;
7776 }
7777 break;
7778
7779 case N32_OP6_ADDI:
7780 if (N32_IMM15S (insn) == 0)
7781 {
7782 /* Do not convert `addi $sp, $sp, 0' to `mov55 $sp, $sp',
7783 because `mov55 $sp, $sp' is ifret16 in V3 ISA. */
7784 if (mach <= MACH_V2
7785 || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7786 {
7787 insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7788 insn_type = NDS32_INSN_MOV55;
7789 }
7790 }
7791 else if (N32_IMM15S (insn) > 0)
7792 {
7793 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) < 8)
7794 {
7795 insn16 = N16_TYPE333 (ADDI333, N32_RT5 (insn), N32_RA5 (insn),
7796 N32_IMM15S (insn));
7797 insn_type = NDS32_INSN_ADDI333;
7798 }
7799 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7800 && N32_IMM15S (insn) < 32)
7801 {
7802 insn16 = N16_TYPE45 (ADDI45, N32_RT54 (insn), N32_IMM15S (insn));
7803 insn_type = NDS32_INSN_ADDI45;
7804 }
7805 else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7806 && N32_RT5 (insn) == N32_RA5 (insn)
7807 && N32_IMM15S (insn) < 512)
7808 {
7809 insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7810 insn_type = NDS32_INSN_ADDI10_SP;
7811 }
7812 else if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7813 && N32_RA5 (insn) == REG_SP && N32_IMM15S (insn) < 256
7814 && (N32_IMM15S (insn) % 4 == 0))
7815 {
7816 insn16 = N16_TYPE36 (ADDRI36_SP, N32_RT5 (insn),
7817 N32_IMM15S (insn) >> 2);
7818 insn_type = NDS32_INSN_ADDRI36_SP;
7819 }
7820 }
7821 else
7822 {
7823 /* Less than 0. */
7824 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) > -8)
7825 {
7826 insn16 = N16_TYPE333 (SUBI333, N32_RT5 (insn), N32_RA5 (insn),
7827 0 - N32_IMM15S (insn));
7828 insn_type = NDS32_INSN_SUBI333;
7829 }
7830 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7831 && N32_IMM15S (insn) > -32)
7832 {
7833 insn16 = N16_TYPE45 (SUBI45, N32_RT54 (insn),
7834 0 - N32_IMM15S (insn));
7835 insn_type = NDS32_INSN_SUBI45;
7836 }
7837 else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7838 && N32_RT5 (insn) == N32_RA5 (insn)
7839 && N32_IMM15S (insn) >= -512)
7840 {
7841 insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7842 insn_type = NDS32_INSN_ADDI10_SP;
7843 }
7844 }
7845 break;
7846
7847 case N32_OP6_ORI:
7848 if (N32_IMM15S (insn) == 0)
7849 {
7850 /* Do not convert `ori $sp, $sp, 0' to `mov55 $sp, $sp',
7851 because `mov55 $sp, $sp' is ifret16 in V3 ISA. */
7852 if (mach <= MACH_V2
7853 || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7854 {
7855 insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7856 insn_type = NDS32_INSN_MOV55;
7857 }
7858 }
7859 break;
7860
7861 case N32_OP6_SUBRI:
7862 if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7863 && N32_IS_RA3 (insn) && N32_IMM15S (insn) == 0)
7864 {
7865 insn16 = N16_MISC33 (NEG33, N32_RT5 (insn), N32_RA5 (insn));
7866 insn_type = NDS32_INSN_NEG33;
7867 }
7868 break;
7869
7870 case N32_OP6_ANDI:
7871 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7872 {
7873 if (N32_IMM15U (insn) == 1)
7874 {
7875 insn16 = N16_BFMI333 (XLSB33, N32_RT5 (insn), N32_RA5 (insn));
7876 insn_type = NDS32_INSN_XLSB33;
7877 }
7878 else if (N32_IMM15U (insn) == 0x7ff)
7879 {
7880 insn16 = N16_BFMI333 (X11B33, N32_RT5 (insn), N32_RA5 (insn));
7881 insn_type = NDS32_INSN_X11B33;
7882 }
7883 else if (N32_IMM15U (insn) == 0xff)
7884 {
7885 insn16 = N16_BFMI333 (ZEB33, N32_RT5 (insn), N32_RA5 (insn));
7886 insn_type = NDS32_INSN_ZEB33;
7887 }
7888 else if (mach >= MACH_V3 && N32_RT5 (insn) == N32_RA5 (insn)
7889 && N32_IMM15U (insn) < 256)
7890 {
7891 int imm15u = N32_IMM15U (insn);
7892
7893 if (__builtin_popcount (imm15u) == 1)
7894 {
7895 /* BMSKI33 */
7896 int imm3u = __builtin_ctz (imm15u);
7897
7898 insn16 = N16_BFMI333 (BMSKI33, N32_RT5 (insn), imm3u);
7899 insn_type = NDS32_INSN_BMSKI33;
7900 }
7901 else if (imm15u != 0 && __builtin_popcount (imm15u + 1) == 1)
7902 {
7903 /* FEXTI33 */
7904 int imm3u = __builtin_ctz (imm15u + 1) - 1;
7905
7906 insn16 = N16_BFMI333 (FEXTI33, N32_RT5 (insn), imm3u);
7907 insn_type = NDS32_INSN_FEXTI33;
7908 }
7909 }
7910 }
7911 break;
7912
7913 case N32_OP6_SLTI:
7914 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
7915 && IS_WITHIN_U (N32_IMM15S (insn), 5))
7916 {
7917 insn16 = N16_TYPE45 (SLTI45, N32_RA54 (insn), N32_IMM15S (insn));
7918 insn_type = NDS32_INSN_SLTI45;
7919 }
7920 break;
7921
7922 case N32_OP6_SLTSI:
7923 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
7924 && IS_WITHIN_U (N32_IMM15S (insn), 5))
7925 {
7926 insn16 = N16_TYPE45 (SLTSI45, N32_RA54 (insn), N32_IMM15S (insn));
7927 insn_type = NDS32_INSN_SLTSI45;
7928 }
7929 break;
7930
7931 case N32_OP6_LWI:
7932 if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
7933 {
7934 insn16 = N16_TYPE45 (LWI450, N32_RT54 (insn), N32_RA5 (insn));
7935 insn_type = NDS32_INSN_LWI450;
7936 }
7937 else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7938 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7939 {
7940 insn16 = N16_TYPE333 (LWI333, N32_RT5 (insn), N32_RA5 (insn),
7941 N32_IMM15S (insn));
7942 insn_type = NDS32_INSN_LWI333;
7943 }
7944 else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
7945 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7946 {
7947 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
7948 insn_type = NDS32_INSN_LWI37;
7949 }
7950 else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
7951 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7952 {
7953 insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 0, N32_IMM15S (insn));
7954 insn_type = NDS32_INSN_LWI37_SP;
7955 }
7956 else if (mach >= MACH_V2 && N32_IS_RT4 (insn) && N32_RA5 (insn) == REG_R8
7957 && -32 <= N32_IMM15S (insn) && N32_IMM15S (insn) < 0)
7958 {
7959 insn16 = N16_TYPE45 (LWI45_FE, N32_RT54 (insn),
7960 N32_IMM15S (insn) + 32);
7961 insn_type = NDS32_INSN_LWI45_FE;
7962 }
7963 break;
7964
7965 case N32_OP6_SWI:
7966 if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
7967 {
7968 insn16 = N16_TYPE45 (SWI450, N32_RT54 (insn), N32_RA5 (insn));
7969 insn_type = NDS32_INSN_SWI450;
7970 }
7971 else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7972 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7973 {
7974 insn16 = N16_TYPE333 (SWI333, N32_RT5 (insn), N32_RA5 (insn),
7975 N32_IMM15S (insn));
7976 insn_type = NDS32_INSN_SWI333;
7977 }
7978 else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
7979 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7980 {
7981 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
7982 insn_type = NDS32_INSN_SWI37;
7983 }
7984 else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
7985 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7986 {
7987 insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 1, N32_IMM15S (insn));
7988 insn_type = NDS32_INSN_SWI37_SP;
7989 }
7990 break;
7991
7992 case N32_OP6_LWI_BI:
7993 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7994 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7995 {
7996 insn16 = N16_TYPE333 (LWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
7997 N32_IMM15S (insn));
7998 insn_type = NDS32_INSN_LWI333_BI;
7999 }
8000 break;
8001
8002 case N32_OP6_SWI_BI:
8003 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8004 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8005 {
8006 insn16 = N16_TYPE333 (SWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
8007 N32_IMM15S (insn));
8008 insn_type = NDS32_INSN_SWI333_BI;
8009 }
8010 break;
8011
8012 case N32_OP6_LHI:
8013 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8014 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8015 {
8016 insn16 = N16_TYPE333 (LHI333, N32_RT5 (insn), N32_RA5 (insn),
8017 N32_IMM15S (insn));
8018 insn_type = NDS32_INSN_LHI333;
8019 }
8020 break;
8021
8022 case N32_OP6_SHI:
8023 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8024 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8025 {
8026 insn16 = N16_TYPE333 (SHI333, N32_RT5 (insn), N32_RA5 (insn),
8027 N32_IMM15S (insn));
8028 insn_type = NDS32_INSN_SHI333;
8029 }
8030 break;
8031
8032 case N32_OP6_LBI:
8033 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8034 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8035 {
8036 insn16 = N16_TYPE333 (LBI333, N32_RT5 (insn), N32_RA5 (insn),
8037 N32_IMM15S (insn));
8038 insn_type = NDS32_INSN_LBI333;
8039 }
8040 break;
8041
8042 case N32_OP6_SBI:
8043 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8044 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8045 {
8046 insn16 = N16_TYPE333 (SBI333, N32_RT5 (insn), N32_RA5 (insn),
8047 N32_IMM15S (insn));
8048 insn_type = NDS32_INSN_SBI333;
8049 }
8050 break;
8051
8052 case N32_OP6_ALU1:
8053 return nds32_convert_32_to_16_alu1 (abfd, insn, pinsn16, pinsn_type);
8054
8055 case N32_OP6_ALU2:
8056 return nds32_convert_32_to_16_alu2 (abfd, insn, pinsn16, pinsn_type);
8057
8058 case N32_OP6_BR1:
8059 if (!IS_WITHIN_S (N32_IMM14S (insn), 8))
8060 goto done;
8061
8062 if ((insn & N32_BIT (14)) == 0)
8063 {
8064 /* N32_BR1_BEQ */
8065 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
8066 && N32_RT5 (insn) != REG_R5)
8067 insn16 = N16_TYPE38 (BEQS38, N32_RT5 (insn), N32_IMM14S (insn));
8068 else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
8069 && N32_RA5 (insn) != REG_R5)
8070 insn16 = N16_TYPE38 (BEQS38, N32_RA5 (insn), N32_IMM14S (insn));
8071 insn_type = NDS32_INSN_BEQS38;
8072 break;
8073 }
8074 else
8075 {
8076 /* N32_BR1_BNE */
8077 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
8078 && N32_RT5 (insn) != REG_R5)
8079 insn16 = N16_TYPE38 (BNES38, N32_RT5 (insn), N32_IMM14S (insn));
8080 else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
8081 && N32_RA5 (insn) != REG_R5)
8082 insn16 = N16_TYPE38 (BNES38, N32_RA5 (insn), N32_IMM14S (insn));
8083 insn_type = NDS32_INSN_BNES38;
8084 break;
8085 }
8086 break;
8087
8088 case N32_OP6_BR2:
8089 switch (N32_BR2_SUB (insn))
8090 {
8091 case N32_BR2_BEQZ:
8092 if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
8093 {
8094 insn16 = N16_TYPE38 (BEQZ38, N32_RT5 (insn), N32_IMM16S (insn));
8095 insn_type = NDS32_INSN_BEQZ38;
8096 }
8097 else if (N32_RT5 (insn) == REG_R15
8098 && IS_WITHIN_S (N32_IMM16S (insn), 8))
8099 {
8100 insn16 = N16_TYPE8 (BEQZS8, N32_IMM16S (insn));
8101 insn_type = NDS32_INSN_BEQZS8;
8102 }
8103 break;
8104
8105 case N32_BR2_BNEZ:
8106 if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
8107 {
8108 insn16 = N16_TYPE38 (BNEZ38, N32_RT5 (insn), N32_IMM16S (insn));
8109 insn_type = NDS32_INSN_BNEZ38;
8110 }
8111 else if (N32_RT5 (insn) == REG_R15
8112 && IS_WITHIN_S (N32_IMM16S (insn), 8))
8113 {
8114 insn16 = N16_TYPE8 (BNEZS8, N32_IMM16S (insn));
8115 insn_type = NDS32_INSN_BNEZS8;
8116 }
8117 break;
8118
8119 case N32_BR2_SOP0:
8120 if (__GF (insn, 20, 5) == 0 && IS_WITHIN_U (N32_IMM16S (insn), 9))
8121 {
8122 insn16 = N16_TYPE9 (IFCALL9, N32_IMM16S (insn));
8123 insn_type = NDS32_INSN_IFCALL9;
8124 }
8125 break;
8126 }
8127 break;
8128
8129 case N32_OP6_JI:
8130 if ((insn & N32_BIT (24)) == 0)
8131 {
8132 /* N32_JI_J */
8133 if (IS_WITHIN_S (N32_IMM24S (insn), 8))
8134 {
8135 insn16 = N16_TYPE8 (J8, N32_IMM24S (insn));
8136 insn_type = NDS32_INSN_J8;
8137 }
8138 }
8139 break;
8140
8141 case N32_OP6_JREG:
8142 if (__GF (insn, 8, 2) != 0)
8143 goto done;
8144
8145 switch (N32_IMMU (insn, 5))
8146 {
8147 case N32_JREG_JR:
8148 if (N32_JREG_HINT (insn) == 0)
8149 {
8150 /* jr */
8151 insn16 = N16_TYPE5 (JR5, N32_RB5 (insn));
8152 insn_type = NDS32_INSN_JR5;
8153 }
8154 else if (N32_JREG_HINT (insn) == 1)
8155 {
8156 /* ret */
8157 insn16 = N16_TYPE5 (RET5, N32_RB5 (insn));
8158 insn_type = NDS32_INSN_RET5;
8159 }
8160 else if (N32_JREG_HINT (insn) == 3)
8161 {
8162 /* ifret = mov55 $sp, $sp */
8163 insn16 = N16_TYPE55 (MOV55, REG_SP, REG_SP);
8164 insn_type = NDS32_INSN_IFRET;
8165 }
8166 break;
8167
8168 case N32_JREG_JRAL:
8169 /* It's convertible when return rt5 is $lp and address
8170 translation is kept. */
8171 if (N32_RT5 (insn) == REG_LP && N32_JREG_HINT (insn) == 0)
8172 {
8173 insn16 = N16_TYPE5 (JRAL5, N32_RB5 (insn));
8174 insn_type = NDS32_INSN_JRAL5;
8175 }
8176 break;
8177 }
8178 break;
8179
8180 case N32_OP6_MISC:
8181 if (N32_SUB5 (insn) == N32_MISC_BREAK && N32_SWID (insn) < 32)
8182 {
8183 /* For v3, swid above 31 are used for ex9.it. */
8184 insn16 = N16_TYPE5 (BREAK16, N32_SWID (insn));
8185 insn_type = NDS32_INSN_BREAK16;
8186 }
8187 break;
8188
8189 default:
8190 /* This instruction has no 16-bit variant. */
8191 goto done;
8192 }
8193
8194 done:
8195 /* Bit-15 of insn16 should be set for a valid instruction. */
8196 if ((insn16 & 0x8000) == 0)
8197 return 0;
8198
8199 if (pinsn16)
8200 *pinsn16 = insn16;
8201 if (pinsn_type)
8202 *pinsn_type = insn_type;
8203 return 1;
8204 }
8205
8206 static int
8207 special_convert_32_to_16 (unsigned long insn, uint16_t *pinsn16,
8208 Elf_Internal_Rela *reloc)
8209 {
8210 uint16_t insn16 = 0;
8211
8212 if ((reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG) == 0
8213 || (ELF32_R_TYPE (reloc->r_info) != R_NDS32_INSN16))
8214 return 0;
8215
8216 if (!N32_IS_RT3 (insn))
8217 return 0;
8218
8219 switch (N32_OP6 (insn))
8220 {
8221 case N32_OP6_LWI:
8222 if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
8223 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
8224 break;
8225 case N32_OP6_SWI:
8226 if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
8227 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
8228 break;
8229 case N32_OP6_HWGP:
8230 if (!IS_WITHIN_U (N32_IMM17S (insn), 7))
8231 break;
8232
8233 if (__GF (insn, 17, 3) == 6)
8234 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM17S (insn));
8235 else if (__GF (insn, 17, 3) == 7)
8236 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM17S (insn));
8237 break;
8238 }
8239
8240 if ((insn16 & 0x8000) == 0)
8241 return 0;
8242
8243 *pinsn16 = insn16;
8244 return 1;
8245 }
8246
8247 /* Convert a 16-bit instruction to 32-bit one.
8248 INSN16 it the input and PINSN it the point to output.
8249 Return non-zero on successful. Otherwise 0 is returned. */
8250
8251 int
8252 nds32_convert_16_to_32 (bfd *abfd, uint16_t insn16, uint32_t *pinsn)
8253 {
8254 uint32_t insn = 0xffffffff;
8255 unsigned long mach = bfd_get_mach (abfd);
8256
8257 /* NOTE: push25, pop25 and movd44 do not have 32-bit variants. */
8258
8259 switch (__GF (insn16, 9, 6))
8260 {
8261 case 0x4: /* add45 */
8262 insn = N32_ALU1 (ADD, N16_RT4 (insn16), N16_RT4 (insn16),
8263 N16_RA5 (insn16));
8264 goto done;
8265 case 0x5: /* sub45 */
8266 insn = N32_ALU1 (SUB, N16_RT4 (insn16), N16_RT4 (insn16),
8267 N16_RA5 (insn16));
8268 goto done;
8269 case 0x6: /* addi45 */
8270 insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
8271 N16_IMM5U (insn16));
8272 goto done;
8273 case 0x7: /* subi45 */
8274 insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
8275 -N16_IMM5U (insn16));
8276 goto done;
8277 case 0x8: /* srai45 */
8278 insn = N32_ALU1 (SRAI, N16_RT4 (insn16), N16_RT4 (insn16),
8279 N16_IMM5U (insn16));
8280 goto done;
8281 case 0x9: /* srli45 */
8282 insn = N32_ALU1 (SRLI, N16_RT4 (insn16), N16_RT4 (insn16),
8283 N16_IMM5U (insn16));
8284 goto done;
8285 case 0xa: /* slli333 */
8286 insn = N32_ALU1 (SLLI, N16_RT3 (insn16), N16_RA3 (insn16),
8287 N16_IMM3U (insn16));
8288 goto done;
8289 case 0xc: /* add333 */
8290 insn = N32_ALU1 (ADD, N16_RT3 (insn16), N16_RA3 (insn16),
8291 N16_RB3 (insn16));
8292 goto done;
8293 case 0xd: /* sub333 */
8294 insn = N32_ALU1 (SUB, N16_RT3 (insn16), N16_RA3 (insn16),
8295 N16_RB3 (insn16));
8296 goto done;
8297 case 0xe: /* addi333 */
8298 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
8299 N16_IMM3U (insn16));
8300 goto done;
8301 case 0xf: /* subi333 */
8302 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
8303 -N16_IMM3U (insn16));
8304 goto done;
8305 case 0x10: /* lwi333 */
8306 insn = N32_TYPE2 (LWI, N16_RT3 (insn16), N16_RA3 (insn16),
8307 N16_IMM3U (insn16));
8308 goto done;
8309 case 0x12: /* lhi333 */
8310 insn = N32_TYPE2 (LHI, N16_RT3 (insn16), N16_RA3 (insn16),
8311 N16_IMM3U (insn16));
8312 goto done;
8313 case 0x13: /* lbi333 */
8314 insn = N32_TYPE2 (LBI, N16_RT3 (insn16), N16_RA3 (insn16),
8315 N16_IMM3U (insn16));
8316 goto done;
8317 case 0x11: /* lwi333.bi */
8318 insn = N32_TYPE2 (LWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
8319 N16_IMM3U (insn16));
8320 goto done;
8321 case 0x14: /* swi333 */
8322 insn = N32_TYPE2 (SWI, N16_RT3 (insn16), N16_RA3 (insn16),
8323 N16_IMM3U (insn16));
8324 goto done;
8325 case 0x16: /* shi333 */
8326 insn = N32_TYPE2 (SHI, N16_RT3 (insn16), N16_RA3 (insn16),
8327 N16_IMM3U (insn16));
8328 goto done;
8329 case 0x17: /* sbi333 */
8330 insn = N32_TYPE2 (SBI, N16_RT3 (insn16), N16_RA3 (insn16),
8331 N16_IMM3U (insn16));
8332 goto done;
8333 case 0x15: /* swi333.bi */
8334 insn = N32_TYPE2 (SWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
8335 N16_IMM3U (insn16));
8336 goto done;
8337 case 0x18: /* addri36.sp */
8338 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), REG_SP,
8339 N16_IMM6U (insn16) << 2);
8340 goto done;
8341 case 0x19: /* lwi45.fe */
8342 insn = N32_TYPE2 (LWI, N16_RT4 (insn16), REG_R8,
8343 (N16_IMM5U (insn16) - 32));
8344 goto done;
8345 case 0x1a: /* lwi450 */
8346 insn = N32_TYPE2 (LWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
8347 goto done;
8348 case 0x1b: /* swi450 */
8349 insn = N32_TYPE2 (SWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
8350 goto done;
8351
8352 /* These are r15 implied instructions. */
8353 case 0x30: /* slts45 */
8354 insn = N32_ALU1 (SLTS, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
8355 goto done;
8356 case 0x31: /* slt45 */
8357 insn = N32_ALU1 (SLT, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
8358 goto done;
8359 case 0x32: /* sltsi45 */
8360 insn = N32_TYPE2 (SLTSI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
8361 goto done;
8362 case 0x33: /* slti45 */
8363 insn = N32_TYPE2 (SLTI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
8364 goto done;
8365 case 0x34: /* beqzs8, bnezs8 */
8366 if (insn16 & N32_BIT (8))
8367 insn = N32_BR2 (BNEZ, REG_TA, N16_IMM8S (insn16));
8368 else
8369 insn = N32_BR2 (BEQZ, REG_TA, N16_IMM8S (insn16));
8370 goto done;
8371
8372 case 0x35: /* break16, ex9.it */
8373 /* Only consider range of v3 break16. */
8374 insn = N32_TYPE0 (MISC, (N16_IMM5U (insn16) << 5) | N32_MISC_BREAK);
8375 goto done;
8376
8377 case 0x3c: /* ifcall9 */
8378 insn = N32_BR2 (SOP0, 0, N16_IMM9U (insn16));
8379 goto done;
8380 case 0x3d: /* movpi45 */
8381 insn = N32_TYPE1 (MOVI, N16_RT4 (insn16), N16_IMM5U (insn16) + 16);
8382 goto done;
8383
8384 case 0x3f: /* MISC33 */
8385 switch (insn16 & 0x7)
8386 {
8387 case 2: /* neg33 */
8388 insn = N32_TYPE2 (SUBRI, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8389 break;
8390 case 3: /* not33 */
8391 insn = N32_ALU1 (NOR, N16_RT3 (insn16), N16_RA3 (insn16),
8392 N16_RA3 (insn16));
8393 break;
8394 case 4: /* mul33 */
8395 insn = N32_ALU2 (MUL, N16_RT3 (insn16), N16_RT3 (insn16),
8396 N16_RA3 (insn16));
8397 break;
8398 case 5: /* xor33 */
8399 insn = N32_ALU1 (XOR, N16_RT3 (insn16), N16_RT3 (insn16),
8400 N16_RA3 (insn16));
8401 break;
8402 case 6: /* and33 */
8403 insn = N32_ALU1 (AND, N16_RT3 (insn16), N16_RT3 (insn16),
8404 N16_RA3 (insn16));
8405 break;
8406 case 7: /* or33 */
8407 insn = N32_ALU1 (OR, N16_RT3 (insn16), N16_RT3 (insn16),
8408 N16_RA3 (insn16));
8409 break;
8410 }
8411 goto done;
8412
8413 case 0xb:
8414 switch (insn16 & 0x7)
8415 {
8416 case 0: /* zeb33 */
8417 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0xff);
8418 break;
8419 case 1: /* zeh33 */
8420 insn = N32_ALU1 (ZEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8421 break;
8422 case 2: /* seb33 */
8423 insn = N32_ALU1 (SEB, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8424 break;
8425 case 3: /* seh33 */
8426 insn = N32_ALU1 (SEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8427 break;
8428 case 4: /* xlsb33 */
8429 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 1);
8430 break;
8431 case 5: /* x11b33 */
8432 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0x7ff);
8433 break;
8434 case 6: /* bmski33 */
8435 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
8436 1 << __GF (insn16, 3, 3));
8437 break;
8438 case 7: /* fexti33 */
8439 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
8440 (1 << (__GF (insn16, 3, 3) + 1)) - 1);
8441 break;
8442 }
8443 goto done;
8444 }
8445
8446 switch (__GF (insn16, 10, 5))
8447 {
8448 case 0x0: /* mov55 or ifret16 */
8449 if (mach >= MACH_V3 && N16_RT5 (insn16) == REG_SP
8450 && N16_RT5 (insn16) == N16_RA5 (insn16))
8451 insn = N32_JREG (JR, 0, 0, 0, 3);
8452 else
8453 insn = N32_TYPE2 (ADDI, N16_RT5 (insn16), N16_RA5 (insn16), 0);
8454 goto done;
8455 case 0x1: /* movi55 */
8456 insn = N32_TYPE1 (MOVI, N16_RT5 (insn16), N16_IMM5S (insn16));
8457 goto done;
8458 case 0x1b: /* addi10s (V2) */
8459 insn = N32_TYPE2 (ADDI, REG_SP, REG_SP, N16_IMM10S (insn16));
8460 goto done;
8461 }
8462
8463 switch (__GF (insn16, 11, 4))
8464 {
8465 case 0x7: /* lwi37.fp/swi37.fp */
8466 if (insn16 & N32_BIT (7)) /* swi37.fp */
8467 insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
8468 else /* lwi37.fp */
8469 insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
8470 goto done;
8471 case 0x8: /* beqz38 */
8472 insn = N32_BR2 (BEQZ, N16_RT38 (insn16), N16_IMM8S (insn16));
8473 goto done;
8474 case 0x9: /* bnez38 */
8475 insn = N32_BR2 (BNEZ, N16_RT38 (insn16), N16_IMM8S (insn16));
8476 goto done;
8477 case 0xa: /* beqs38/j8, implied r5 */
8478 if (N16_RT38 (insn16) == 5)
8479 insn = N32_JI (J, N16_IMM8S (insn16));
8480 else
8481 insn = N32_BR1 (BEQ, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
8482 goto done;
8483 case 0xb: /* bnes38 and others. */
8484 if (N16_RT38 (insn16) == 5)
8485 {
8486 switch (__GF (insn16, 5, 3))
8487 {
8488 case 0: /* jr5 */
8489 insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 0);
8490 break;
8491 case 4: /* ret5 */
8492 insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 1);
8493 break;
8494 case 1: /* jral5 */
8495 insn = N32_JREG (JRAL, REG_LP, N16_RA5 (insn16), 0, 0);
8496 break;
8497 case 2: /* ex9.it imm5 */
8498 /* ex9.it had no 32-bit variantl. */
8499 break;
8500 case 5: /* add5.pc */
8501 /* add5.pc had no 32-bit variantl. */
8502 break;
8503 }
8504 }
8505 else /* bnes38 */
8506 insn = N32_BR1 (BNE, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
8507 goto done;
8508 case 0xe: /* lwi37/swi37 */
8509 if (insn16 & (1 << 7)) /* swi37.sp */
8510 insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
8511 else /* lwi37.sp */
8512 insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
8513 goto done;
8514 }
8515
8516 done:
8517 if (insn & 0x80000000)
8518 return 0;
8519
8520 if (pinsn)
8521 *pinsn = insn;
8522 return 1;
8523 }
8524 \f
8525
8526 static bfd_boolean
8527 is_sda_access_insn (unsigned long insn)
8528 {
8529 switch (N32_OP6 (insn))
8530 {
8531 case N32_OP6_LWI:
8532 case N32_OP6_LHI:
8533 case N32_OP6_LHSI:
8534 case N32_OP6_LBI:
8535 case N32_OP6_LBSI:
8536 case N32_OP6_SWI:
8537 case N32_OP6_SHI:
8538 case N32_OP6_SBI:
8539 case N32_OP6_LWC:
8540 case N32_OP6_LDC:
8541 case N32_OP6_SWC:
8542 case N32_OP6_SDC:
8543 return TRUE;
8544 default:
8545 ;
8546 }
8547 return FALSE;
8548 }
8549
8550 static unsigned long
8551 turn_insn_to_sda_access (uint32_t insn, bfd_signed_vma type, uint32_t *pinsn)
8552 {
8553 uint32_t oinsn = 0;
8554
8555 switch (type)
8556 {
8557 case R_NDS32_GOT_LO12:
8558 case R_NDS32_GOTOFF_LO12:
8559 case R_NDS32_PLTREL_LO12:
8560 case R_NDS32_PLT_GOTREL_LO12:
8561 case R_NDS32_LO12S0_RELA:
8562 switch (N32_OP6 (insn))
8563 {
8564 case N32_OP6_LBI:
8565 /* lbi.gp */
8566 oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
8567 break;
8568 case N32_OP6_LBSI:
8569 /* lbsi.gp */
8570 oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), N32_BIT (19));
8571 break;
8572 case N32_OP6_SBI:
8573 /* sbi.gp */
8574 oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
8575 break;
8576 case N32_OP6_ORI:
8577 /* addi.gp */
8578 oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), N32_BIT (19));
8579 break;
8580 }
8581 break;
8582
8583 case R_NDS32_LO12S1_RELA:
8584 switch (N32_OP6 (insn))
8585 {
8586 case N32_OP6_LHI:
8587 /* lhi.gp */
8588 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
8589 break;
8590 case N32_OP6_LHSI:
8591 /* lhsi.gp */
8592 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (18));
8593 break;
8594 case N32_OP6_SHI:
8595 /* shi.gp */
8596 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (19));
8597 break;
8598 }
8599 break;
8600
8601 case R_NDS32_LO12S2_RELA:
8602 switch (N32_OP6 (insn))
8603 {
8604 case N32_OP6_LWI:
8605 /* lwi.gp */
8606 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
8607 break;
8608 case N32_OP6_SWI:
8609 /* swi.gp */
8610 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
8611 break;
8612 }
8613 break;
8614
8615 case R_NDS32_LO12S2_DP_RELA:
8616 case R_NDS32_LO12S2_SP_RELA:
8617 oinsn = (insn & 0x7ff07000) | (REG_GP << 15);
8618 break;
8619 }
8620
8621 if (oinsn)
8622 *pinsn = oinsn;
8623
8624 return oinsn != 0;
8625 }
8626
8627 /* Linker hasn't found the correct merge section for non-section symbol
8628 in relax time, this work is left to the function elf_link_input_bfd().
8629 So for non-section symbol, _bfd_merged_section_offset is also needed
8630 to find the correct symbol address. */
8631
8632 static bfd_vma
8633 nds32_elf_rela_local_sym (bfd *abfd, Elf_Internal_Sym *sym,
8634 asection **psec, Elf_Internal_Rela *rel)
8635 {
8636 asection *sec = *psec;
8637 bfd_vma relocation;
8638
8639 relocation = (sec->output_section->vma
8640 + sec->output_offset + sym->st_value);
8641 if ((sec->flags & SEC_MERGE) && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
8642 {
8643 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
8644 rel->r_addend =
8645 _bfd_merged_section_offset (abfd, psec,
8646 elf_section_data (sec)->sec_info,
8647 sym->st_value + rel->r_addend);
8648 else
8649 rel->r_addend =
8650 _bfd_merged_section_offset (abfd, psec,
8651 elf_section_data (sec)->sec_info,
8652 sym->st_value) + rel->r_addend;
8653
8654 if (sec != *psec)
8655 {
8656 /* If we have changed the section, and our original section is
8657 marked with SEC_EXCLUDE, it means that the original
8658 SEC_MERGE section has been completely subsumed in some
8659 other SEC_MERGE section. In this case, we need to leave
8660 some info around for --emit-relocs. */
8661 if ((sec->flags & SEC_EXCLUDE) != 0)
8662 sec->kept_section = *psec;
8663 sec = *psec;
8664 }
8665 rel->r_addend -= relocation;
8666 rel->r_addend += sec->output_section->vma + sec->output_offset;
8667 }
8668 return relocation;
8669 }
8670
8671 static bfd_vma
8672 calculate_memory_address (bfd *abfd, Elf_Internal_Rela *irel,
8673 Elf_Internal_Sym *isymbuf,
8674 Elf_Internal_Shdr *symtab_hdr)
8675 {
8676 bfd_signed_vma foff;
8677 bfd_vma symval, addend;
8678 Elf_Internal_Rela irel_fn;
8679 Elf_Internal_Sym *isym;
8680 asection *sym_sec;
8681
8682 /* Get the value of the symbol referred to by the reloc. */
8683 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
8684 {
8685 /* A local symbol. */
8686 isym = isymbuf + ELF32_R_SYM (irel->r_info);
8687
8688 if (isym->st_shndx == SHN_UNDEF)
8689 sym_sec = bfd_und_section_ptr;
8690 else if (isym->st_shndx == SHN_ABS)
8691 sym_sec = bfd_abs_section_ptr;
8692 else if (isym->st_shndx == SHN_COMMON)
8693 sym_sec = bfd_com_section_ptr;
8694 else
8695 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
8696 memcpy (&irel_fn, irel, sizeof (Elf_Internal_Rela));
8697 symval = nds32_elf_rela_local_sym (abfd, isym, &sym_sec, &irel_fn);
8698 addend = irel_fn.r_addend;
8699 }
8700 else
8701 {
8702 unsigned long indx;
8703 struct elf_link_hash_entry *h;
8704
8705 /* An external symbol. */
8706 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
8707 h = elf_sym_hashes (abfd)[indx];
8708 BFD_ASSERT (h != NULL);
8709
8710 while (h->root.type == bfd_link_hash_indirect
8711 || h->root.type == bfd_link_hash_warning)
8712 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8713
8714 if (h->root.type != bfd_link_hash_defined
8715 && h->root.type != bfd_link_hash_defweak)
8716 /* This appears to be a reference to an undefined
8717 symbol. Just ignore it--it will be caught by the
8718 regular reloc processing. */
8719 return 0;
8720
8721 if (h->root.u.def.section->flags & SEC_MERGE)
8722 {
8723 sym_sec = h->root.u.def.section;
8724 symval = _bfd_merged_section_offset (abfd, &sym_sec, elf_section_data
8725 (sym_sec)->sec_info, h->root.u.def.value);
8726 symval = symval + sym_sec->output_section->vma
8727 + sym_sec->output_offset;
8728 }
8729 else
8730 symval = (h->root.u.def.value
8731 + h->root.u.def.section->output_section->vma
8732 + h->root.u.def.section->output_offset);
8733 addend = irel->r_addend;
8734 }
8735
8736 foff = symval + addend;
8737
8738 return foff;
8739 }
8740
8741 static int
8742 is_16bit_NOP (bfd *abfd ATTRIBUTE_UNUSED,
8743 asection *sec, Elf_Internal_Rela *rel)
8744 {
8745 bfd_byte *contents;
8746 unsigned short insn16;
8747
8748 if (!(rel->r_addend & R_NDS32_INSN16_CONVERT_FLAG))
8749 return FALSE;
8750 contents = elf_section_data (sec)->this_hdr.contents;
8751 insn16 = bfd_getb16 (contents + rel->r_offset);
8752 if (insn16 == NDS32_NOP16)
8753 return TRUE;
8754 return FALSE;
8755 }
8756
8757 /* It checks whether the instruction could be converted to
8758 16-bit form and returns the converted one.
8759
8760 `internal_relocs' is supposed to be sorted. */
8761
8762 static int
8763 is_convert_32_to_16 (bfd *abfd, asection *sec,
8764 Elf_Internal_Rela *reloc,
8765 Elf_Internal_Rela *internal_relocs,
8766 Elf_Internal_Rela *irelend,
8767 uint16_t *insn16)
8768 {
8769 #define NORMAL_32_TO_16 (1 << 0)
8770 #define SPECIAL_32_TO_16 (1 << 1)
8771 bfd_byte *contents = NULL;
8772 bfd_signed_vma off;
8773 bfd_vma mem_addr;
8774 uint32_t insn = 0;
8775 Elf_Internal_Rela *pc_rel;
8776 Elf_Internal_Shdr *symtab_hdr;
8777 Elf_Internal_Sym *isymbuf = NULL;
8778 int convert_type;
8779 bfd_vma offset;
8780
8781 if (reloc->r_offset + 4 > sec->size)
8782 return FALSE;
8783
8784 offset = reloc->r_offset;
8785
8786 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
8787 return FALSE;
8788 insn = bfd_getb32 (contents + offset);
8789
8790 if (nds32_convert_32_to_16 (abfd, insn, insn16, NULL))
8791 convert_type = NORMAL_32_TO_16;
8792 else if (special_convert_32_to_16 (insn, insn16, reloc))
8793 convert_type = SPECIAL_32_TO_16;
8794 else
8795 return FALSE;
8796
8797 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8798 if (!nds32_get_local_syms (abfd, sec, &isymbuf))
8799 return FALSE;
8800
8801 /* Find the first relocation of the same relocation-type,
8802 so we iteratie them forward. */
8803 pc_rel = reloc;
8804 while ((pc_rel - 1) >= internal_relocs && pc_rel[-1].r_offset == offset)
8805 pc_rel--;
8806
8807 for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8808 {
8809 if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8810 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8811 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA
8812 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8813 {
8814 off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr);
8815 if (off >= ACCURATE_8BIT_S1 || off < -ACCURATE_8BIT_S1
8816 || off == 0)
8817 return FALSE;
8818 break;
8819 }
8820 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8821 {
8822 /* movi => movi55 */
8823 mem_addr = calculate_memory_address (abfd, pc_rel, isymbuf,
8824 symtab_hdr);
8825 /* mem_addr is unsigned, but the value should
8826 be between [-16, 15]. */
8827 if ((mem_addr + 0x10) >> 5)
8828 return FALSE;
8829 break;
8830 }
8831 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_20)
8832 || (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_LO12))
8833 {
8834 /* It never happen movi to movi55 for R_NDS32_TLS_LE_20,
8835 because it can be relaxed to addi for TLS_LE_ADD. */
8836 return FALSE;
8837 }
8838 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8839 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8840 && (reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG)
8841 && convert_type == SPECIAL_32_TO_16)
8842 {
8843 /* fp-as-gp
8844 We've selected a best fp-base for this access, so we can
8845 always resolve it anyway. Do nothing. */
8846 break;
8847 }
8848 else if ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_NONE
8849 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_RELA_GNU_VTINHERIT))
8850 || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_RELA_GNU_VTENTRY)
8851 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_INSN16))
8852 || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_LOADSTORE)
8853 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_DWARF2_OP1_RELA)))
8854 {
8855 /* Prevent unresolved addi instruction translate
8856 to addi45 or addi333. */
8857 return FALSE;
8858 }
8859 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8860 {
8861 off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr);
8862 if (off >= ACCURATE_U9BIT_S1 || off <= 0)
8863 return FALSE;
8864 break;
8865 }
8866 }
8867
8868 return TRUE;
8869 }
8870
8871 static void
8872 nds32_elf_write_16 (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *contents,
8873 Elf_Internal_Rela *reloc,
8874 Elf_Internal_Rela *internal_relocs,
8875 Elf_Internal_Rela *irelend,
8876 unsigned short insn16)
8877 {
8878 Elf_Internal_Rela *pc_rel;
8879 bfd_vma offset;
8880
8881 offset = reloc->r_offset;
8882 bfd_putb16 (insn16, contents + offset);
8883 /* Find the first relocation of the same relocation-type,
8884 so we iteratie them forward. */
8885 pc_rel = reloc;
8886 while ((pc_rel - 1) > internal_relocs && pc_rel[-1].r_offset == offset)
8887 pc_rel--;
8888
8889 for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8890 {
8891 if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8892 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8893 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA)
8894 {
8895 pc_rel->r_info =
8896 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PCREL_RELA);
8897 }
8898 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8899 pc_rel->r_info =
8900 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PLTREL);
8901 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8902 pc_rel->r_info =
8903 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_5_RELA);
8904 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8905 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8906 pc_rel->r_info =
8907 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_SDA_FP7U2_RELA);
8908 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8909 pc_rel->r_info =
8910 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_10IFCU_PCREL_RELA);
8911 }
8912 }
8913
8914 /* Find a relocation of type specified by `reloc_type'
8915 of the same r_offset with reloc.
8916 If not found, return irelend.
8917
8918 Assuming relocations are sorted by r_offset,
8919 we find the relocation from `reloc' backward untill relocs,
8920 or find it from `reloc' forward untill irelend. */
8921
8922 static Elf_Internal_Rela *
8923 find_relocs_at_address (Elf_Internal_Rela *reloc,
8924 Elf_Internal_Rela *relocs,
8925 Elf_Internal_Rela *irelend,
8926 enum elf_nds32_reloc_type reloc_type)
8927 {
8928 Elf_Internal_Rela *rel_t;
8929
8930 /* Find backward. */
8931 for (rel_t = reloc;
8932 rel_t >= relocs && rel_t->r_offset == reloc->r_offset;
8933 rel_t--)
8934 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8935 return rel_t;
8936
8937 /* We didn't find it backward. Try find it forward. */
8938 for (rel_t = reloc;
8939 rel_t < irelend && rel_t->r_offset == reloc->r_offset;
8940 rel_t++)
8941 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8942 return rel_t;
8943
8944 return irelend;
8945 }
8946
8947 /* Find a relocation of specified type and offset.
8948 `reloc' is just a refence point to find a relocation at specified offset.
8949 If not found, return irelend.
8950
8951 Assuming relocations are sorted by r_offset,
8952 we find the relocation from `reloc' backward untill relocs,
8953 or find it from `reloc' forward untill irelend. */
8954
8955 static Elf_Internal_Rela *
8956 find_relocs_at_address_addr (Elf_Internal_Rela *reloc,
8957 Elf_Internal_Rela *relocs,
8958 Elf_Internal_Rela *irelend,
8959 enum elf_nds32_reloc_type reloc_type,
8960 bfd_vma offset_p)
8961 {
8962 Elf_Internal_Rela *rel_t = NULL;
8963
8964 /* First, we try to find a relocation of offset `offset_p',
8965 and then we use find_relocs_at_address to find specific type. */
8966
8967 if (reloc->r_offset > offset_p)
8968 {
8969 /* Find backward. */
8970 for (rel_t = reloc;
8971 rel_t >= relocs && rel_t->r_offset > offset_p; rel_t--)
8972 /* Do nothing. */;
8973 }
8974 else if (reloc->r_offset < offset_p)
8975 {
8976 /* Find forward. */
8977 for (rel_t = reloc;
8978 rel_t < irelend && rel_t->r_offset < offset_p; rel_t++)
8979 /* Do nothing. */;
8980 }
8981 else
8982 rel_t = reloc;
8983
8984 /* Not found? */
8985 if (rel_t < relocs || rel_t == irelend || rel_t->r_offset != offset_p)
8986 return irelend;
8987
8988 return find_relocs_at_address (rel_t, relocs, irelend, reloc_type);
8989 }
8990
8991 typedef struct nds32_elf_blank nds32_elf_blank_t;
8992 struct nds32_elf_blank
8993 {
8994 /* Where the blank begins. */
8995 bfd_vma offset;
8996 /* The size of the blank. */
8997 bfd_vma size;
8998 /* The accumulative size before this blank. */
8999 bfd_vma total_size;
9000 nds32_elf_blank_t *next;
9001 nds32_elf_blank_t *prev;
9002 };
9003
9004 static nds32_elf_blank_t *blank_free_list = NULL;
9005
9006 static nds32_elf_blank_t *
9007 create_nds32_elf_blank (bfd_vma offset_p, bfd_vma size_p)
9008 {
9009 nds32_elf_blank_t *blank_t;
9010
9011 if (blank_free_list)
9012 {
9013 blank_t = blank_free_list;
9014 blank_free_list = blank_free_list->next;
9015 }
9016 else
9017 blank_t = bfd_malloc (sizeof (nds32_elf_blank_t));
9018
9019 if (blank_t == NULL)
9020 return NULL;
9021
9022 blank_t->offset = offset_p;
9023 blank_t->size = size_p;
9024 blank_t->total_size = 0;
9025 blank_t->next = NULL;
9026 blank_t->prev = NULL;
9027
9028 return blank_t;
9029 }
9030
9031 static void
9032 remove_nds32_elf_blank (nds32_elf_blank_t *blank_p)
9033 {
9034 if (blank_free_list)
9035 {
9036 blank_free_list->prev = blank_p;
9037 blank_p->next = blank_free_list;
9038 }
9039 else
9040 blank_p->next = NULL;
9041
9042 blank_p->prev = NULL;
9043 blank_free_list = blank_p;
9044 }
9045
9046 static void
9047 clean_nds32_elf_blank (void)
9048 {
9049 nds32_elf_blank_t *blank_t;
9050
9051 while (blank_free_list)
9052 {
9053 blank_t = blank_free_list;
9054 blank_free_list = blank_free_list->next;
9055 free (blank_t);
9056 }
9057 }
9058
9059 static nds32_elf_blank_t *
9060 search_nds32_elf_blank (nds32_elf_blank_t *blank_p, bfd_vma addr)
9061 {
9062 nds32_elf_blank_t *blank_t;
9063
9064 if (!blank_p)
9065 return NULL;
9066 blank_t = blank_p;
9067
9068 while (blank_t && addr < blank_t->offset)
9069 blank_t = blank_t->prev;
9070 while (blank_t && blank_t->next && addr >= blank_t->next->offset)
9071 blank_t = blank_t->next;
9072
9073 return blank_t;
9074 }
9075
9076 static bfd_vma
9077 get_nds32_elf_blank_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
9078 int overwrite)
9079 {
9080 nds32_elf_blank_t *blank_t;
9081
9082 blank_t = search_nds32_elf_blank (*blank_p, addr);
9083 if (!blank_t)
9084 return 0;
9085
9086 if (overwrite)
9087 *blank_p = blank_t;
9088
9089 if (addr < blank_t->offset + blank_t->size)
9090 return blank_t->total_size + (addr - blank_t->offset);
9091 else
9092 return blank_t->total_size + blank_t->size;
9093 }
9094
9095 static bfd_boolean
9096 insert_nds32_elf_blank (nds32_elf_blank_t **blank_p, bfd_vma addr, bfd_vma len)
9097 {
9098 nds32_elf_blank_t *blank_t, *blank_t2;
9099
9100 if (!*blank_p)
9101 {
9102 *blank_p = create_nds32_elf_blank (addr, len);
9103 return *blank_p ? TRUE : FALSE;
9104 }
9105
9106 blank_t = search_nds32_elf_blank (*blank_p, addr);
9107
9108 if (blank_t == NULL)
9109 {
9110 blank_t = create_nds32_elf_blank (addr, len);
9111 if (!blank_t)
9112 return FALSE;
9113 while ((*blank_p)->prev != NULL)
9114 *blank_p = (*blank_p)->prev;
9115 blank_t->next = *blank_p;
9116 (*blank_p)->prev = blank_t;
9117 (*blank_p) = blank_t;
9118 return TRUE;
9119 }
9120
9121 if (addr < blank_t->offset + blank_t->size)
9122 {
9123 /* Extend the origin blank. */
9124 if (addr + len > blank_t->offset + blank_t->size)
9125 blank_t->size = addr + len - blank_t->offset;
9126 }
9127 else
9128 {
9129 blank_t2 = create_nds32_elf_blank (addr, len);
9130 if (!blank_t2)
9131 return FALSE;
9132 if (blank_t->next)
9133 {
9134 blank_t->next->prev = blank_t2;
9135 blank_t2->next = blank_t->next;
9136 }
9137 blank_t2->prev = blank_t;
9138 blank_t->next = blank_t2;
9139 *blank_p = blank_t2;
9140 }
9141
9142 return TRUE;
9143 }
9144
9145 static bfd_boolean
9146 insert_nds32_elf_blank_recalc_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
9147 bfd_vma len)
9148 {
9149 nds32_elf_blank_t *blank_t;
9150
9151 if (!insert_nds32_elf_blank (blank_p, addr, len))
9152 return FALSE;
9153
9154 blank_t = *blank_p;
9155
9156 if (!blank_t->prev)
9157 {
9158 blank_t->total_size = 0;
9159 blank_t = blank_t->next;
9160 }
9161
9162 while (blank_t)
9163 {
9164 blank_t->total_size = blank_t->prev->total_size + blank_t->prev->size;
9165 blank_t = blank_t->next;
9166 }
9167
9168 return TRUE;
9169 }
9170
9171 static void
9172 calc_nds32_blank_total (nds32_elf_blank_t *blank_p)
9173 {
9174 nds32_elf_blank_t *blank_t;
9175 bfd_vma total_size = 0;
9176
9177 if (!blank_p)
9178 return;
9179
9180 blank_t = blank_p;
9181 while (blank_t->prev)
9182 blank_t = blank_t->prev;
9183 while (blank_t)
9184 {
9185 blank_t->total_size = total_size;
9186 total_size += blank_t->size;
9187 blank_t = blank_t->next;
9188 }
9189 }
9190
9191 static bfd_boolean
9192 nds32_elf_relax_delete_blanks (bfd *abfd, asection *sec,
9193 nds32_elf_blank_t *blank_p)
9194 {
9195 Elf_Internal_Shdr *symtab_hdr; /* Symbol table header of this bfd. */
9196 Elf_Internal_Sym *isym = NULL; /* Symbol table of this bfd. */
9197 Elf_Internal_Sym *isymend; /* Symbol entry iterator. */
9198 unsigned int sec_shndx; /* The section the be relaxed. */
9199 bfd_byte *contents; /* Contents data of iterating section. */
9200 Elf_Internal_Rela *internal_relocs;
9201 Elf_Internal_Rela *irel;
9202 Elf_Internal_Rela *irelend;
9203 struct elf_link_hash_entry **sym_hashes;
9204 struct elf_link_hash_entry **end_hashes;
9205 unsigned int symcount;
9206 asection *sect;
9207 nds32_elf_blank_t *blank_t;
9208 nds32_elf_blank_t *blank_t2;
9209 nds32_elf_blank_t *blank_head;
9210
9211 blank_head = blank_t = blank_p;
9212 while (blank_head->prev != NULL)
9213 blank_head = blank_head->prev;
9214 while (blank_t->next != NULL)
9215 blank_t = blank_t->next;
9216
9217 if (blank_t->offset + blank_t->size <= sec->size)
9218 {
9219 blank_t->next = create_nds32_elf_blank (sec->size + 4, 0);
9220 blank_t->next->prev = blank_t;
9221 }
9222 if (blank_head->offset > 0)
9223 {
9224 blank_head->prev = create_nds32_elf_blank (0, 0);
9225 blank_head->prev->next = blank_head;
9226 blank_head = blank_head->prev;
9227 }
9228
9229 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
9230
9231 /* The deletion must stop at the next ALIGN reloc for an alignment
9232 power larger than the number of bytes we are deleting. */
9233
9234 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9235 if (!nds32_get_local_syms (abfd, sec, &isym))
9236 return FALSE;
9237
9238 if (isym == NULL)
9239 {
9240 isym = bfd_elf_get_elf_syms (abfd, symtab_hdr,
9241 symtab_hdr->sh_info, 0, NULL, NULL, NULL);
9242 symtab_hdr->contents = (bfd_byte *) isym;
9243 }
9244
9245 if (isym == NULL || symtab_hdr->sh_info == 0)
9246 return FALSE;
9247
9248 blank_t = blank_head;
9249 calc_nds32_blank_total (blank_head);
9250
9251 for (sect = abfd->sections; sect != NULL; sect = sect->next)
9252 {
9253 /* Adjust all the relocs. */
9254
9255 /* Relocations MUST be kept in memory, because relaxation adjust them. */
9256 internal_relocs = _bfd_elf_link_read_relocs (abfd, sect, NULL, NULL,
9257 TRUE /* keep_memory */);
9258 irelend = internal_relocs + sect->reloc_count;
9259
9260 blank_t = blank_head;
9261 blank_t2 = blank_head;
9262
9263 if (!(sect->flags & SEC_RELOC))
9264 continue;
9265
9266 nds32_get_section_contents (abfd, sect, &contents, TRUE);
9267
9268 for (irel = internal_relocs; irel < irelend; irel++)
9269 {
9270 bfd_vma raddr;
9271
9272 if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_DIFF8
9273 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_DIFF32
9274 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
9275 {
9276 unsigned long val = 0;
9277 unsigned long mask;
9278 long before, between;
9279 long offset = 0;
9280
9281 switch (ELF32_R_TYPE (irel->r_info))
9282 {
9283 case R_NDS32_DIFF8:
9284 offset = bfd_get_8 (abfd, contents + irel->r_offset);
9285 break;
9286 case R_NDS32_DIFF16:
9287 offset = bfd_get_16 (abfd, contents + irel->r_offset);
9288 break;
9289 case R_NDS32_DIFF32:
9290 val = bfd_get_32 (abfd, contents + irel->r_offset);
9291 /* Get the signed bit and mask for the high part. The
9292 gcc will alarm when right shift 32-bit since the
9293 type size of long may be 32-bit. */
9294 mask = 0 - (val >> 31);
9295 if (mask)
9296 offset = (val | (mask - 0xffffffff));
9297 else
9298 offset = val;
9299 break;
9300 default:
9301 BFD_ASSERT (0);
9302 }
9303
9304 /* DIFF value
9305 0 |encoded in location|
9306 |------------|-------------------|---------
9307 sym+off(addend)
9308 -- before ---| *****************
9309 --------------------- between ---|
9310
9311 We only care how much data are relax between DIFF,
9312 marked as ***. */
9313
9314 before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
9315 between = get_nds32_elf_blank_total (&blank_t,
9316 irel->r_addend + offset, 0);
9317 if (between == before)
9318 goto done_adjust_diff;
9319
9320 switch (ELF32_R_TYPE (irel->r_info))
9321 {
9322 case R_NDS32_DIFF8:
9323 bfd_put_8 (abfd, offset - (between - before),
9324 contents + irel->r_offset);
9325 break;
9326 case R_NDS32_DIFF16:
9327 bfd_put_16 (abfd, offset - (between - before),
9328 contents + irel->r_offset);
9329 break;
9330 case R_NDS32_DIFF32:
9331 bfd_put_32 (abfd, offset - (between - before),
9332 contents + irel->r_offset);
9333 break;
9334 }
9335 }
9336 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_DIFF_ULEB128
9337 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
9338 {
9339 bfd_vma val = 0;
9340 unsigned int len = 0;
9341 unsigned long before, between;
9342 bfd_byte *endp, *p;
9343
9344 val = _bfd_read_unsigned_leb128 (abfd, contents + irel->r_offset,
9345 &len);
9346
9347 before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
9348 between = get_nds32_elf_blank_total (&blank_t,
9349 irel->r_addend + val, 0);
9350 if (between == before)
9351 goto done_adjust_diff;
9352
9353 p = contents + irel->r_offset;
9354 endp = p + len -1;
9355 memset (p, 0x80, len);
9356 *(endp) = 0;
9357 p = write_uleb128 (p, val - (between - before)) - 1;
9358 if (p < endp)
9359 *p |= 0x80;
9360 }
9361 done_adjust_diff:
9362
9363 if (sec == sect)
9364 {
9365 raddr = irel->r_offset;
9366 irel->r_offset -= get_nds32_elf_blank_total (&blank_t2,
9367 irel->r_offset, 1);
9368
9369 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
9370 continue;
9371 if (blank_t2 && blank_t2->next
9372 && (blank_t2->offset > raddr
9373 || blank_t2->next->offset <= raddr))
9374 _bfd_error_handler
9375 (_("%pB: error: search_nds32_elf_blank reports wrong node"),
9376 abfd);
9377
9378 /* Mark reloc in deleted portion as NONE.
9379 For some relocs like R_NDS32_LABEL that doesn't modify the
9380 content in the section. R_NDS32_LABEL doesn't belong to the
9381 instruction in the section, so we should preserve it. */
9382 if (raddr >= blank_t2->offset
9383 && raddr < blank_t2->offset + blank_t2->size
9384 && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL
9385 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_BEGIN
9386 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
9387 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
9388 && ELF32_R_TYPE (irel->r_info) != R_NDS32_SUBTRAHEND
9389 && ELF32_R_TYPE (irel->r_info) != R_NDS32_MINUEND)
9390 {
9391 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
9392 R_NDS32_NONE);
9393 continue;
9394 }
9395 }
9396
9397 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE
9398 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
9399 || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
9400 continue;
9401
9402 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info
9403 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx
9404 && ELF_ST_TYPE (isym[ELF32_R_SYM (irel->r_info)].st_info) == STT_SECTION)
9405 {
9406 if (irel->r_addend <= sec->size)
9407 irel->r_addend -=
9408 get_nds32_elf_blank_total (&blank_t, irel->r_addend, 1);
9409 }
9410 }
9411 }
9412
9413 /* Adjust the local symbols defined in this section. */
9414 blank_t = blank_head;
9415 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
9416 {
9417 if (isym->st_shndx == sec_shndx)
9418 {
9419 if (isym->st_value <= sec->size)
9420 {
9421 bfd_vma ahead;
9422 bfd_vma orig_addr = isym->st_value;
9423
9424 ahead = get_nds32_elf_blank_total (&blank_t, isym->st_value, 1);
9425 isym->st_value -= ahead;
9426
9427 /* Adjust function size. */
9428 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC
9429 && isym->st_size > 0)
9430 isym->st_size -=
9431 get_nds32_elf_blank_total
9432 (&blank_t, orig_addr + isym->st_size, 0) - ahead;
9433 }
9434 }
9435 }
9436
9437 /* Now adjust the global symbols defined in this section. */
9438 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
9439 - symtab_hdr->sh_info);
9440 sym_hashes = elf_sym_hashes (abfd);
9441 end_hashes = sym_hashes + symcount;
9442 blank_t = blank_head;
9443 for (; sym_hashes < end_hashes; sym_hashes++)
9444 {
9445 struct elf_link_hash_entry *sym_hash = *sym_hashes;
9446
9447 if ((sym_hash->root.type == bfd_link_hash_defined
9448 || sym_hash->root.type == bfd_link_hash_defweak)
9449 && sym_hash->root.u.def.section == sec)
9450 {
9451 if (sym_hash->root.u.def.value <= sec->size)
9452 {
9453 bfd_vma ahead;
9454 bfd_vma orig_addr = sym_hash->root.u.def.value;
9455
9456 ahead = get_nds32_elf_blank_total (&blank_t, sym_hash->root.u.def.value, 1);
9457 sym_hash->root.u.def.value -= ahead;
9458
9459 /* Adjust function size. */
9460 if (sym_hash->type == STT_FUNC)
9461 sym_hash->size -=
9462 get_nds32_elf_blank_total
9463 (&blank_t, orig_addr + sym_hash->size, 0) - ahead;
9464
9465 }
9466 }
9467 }
9468
9469 contents = elf_section_data (sec)->this_hdr.contents;
9470 blank_t = blank_head;
9471 while (blank_t->next)
9472 {
9473 /* Actually delete the bytes. */
9474
9475 /* If current blank is the last blank overlap with current section,
9476 go to finish process. */
9477 if (sec->size <= (blank_t->next->offset))
9478 break;
9479
9480 memmove (contents + blank_t->offset - blank_t->total_size,
9481 contents + blank_t->offset + blank_t->size,
9482 blank_t->next->offset - (blank_t->offset + blank_t->size));
9483
9484 blank_t = blank_t->next;
9485 }
9486
9487 if (sec->size > (blank_t->offset + blank_t->size))
9488 {
9489 /* There are remaining code between blank and section boundary.
9490 Move the remaining code to appropriate location. */
9491 memmove (contents + blank_t->offset - blank_t->total_size,
9492 contents + blank_t->offset + blank_t->size,
9493 sec->size - (blank_t->offset + blank_t->size));
9494 sec->size -= blank_t->total_size + blank_t->size;
9495 }
9496 else
9497 /* This blank is not entirely included in the section,
9498 reduce the section size by only part of the blank size. */
9499 sec->size -= blank_t->total_size + (sec->size - blank_t->offset);
9500
9501 while (blank_head)
9502 {
9503 blank_t = blank_head;
9504 blank_head = blank_head->next;
9505 remove_nds32_elf_blank (blank_t);
9506 }
9507
9508 return TRUE;
9509 }
9510
9511 /* Get the contents of a section. */
9512
9513 static int
9514 nds32_get_section_contents (bfd *abfd, asection *sec,
9515 bfd_byte **contents_p, bfd_boolean cache)
9516 {
9517 /* Get the section contents. */
9518 if (elf_section_data (sec)->this_hdr.contents != NULL)
9519 *contents_p = elf_section_data (sec)->this_hdr.contents;
9520 else
9521 {
9522 if (!bfd_malloc_and_get_section (abfd, sec, contents_p))
9523 return FALSE;
9524 if (cache)
9525 elf_section_data (sec)->this_hdr.contents = *contents_p;
9526 }
9527
9528 return TRUE;
9529 }
9530
9531 /* Get the contents of the internal symbol of abfd. */
9532
9533 static int
9534 nds32_get_local_syms (bfd *abfd, asection *sec ATTRIBUTE_UNUSED,
9535 Elf_Internal_Sym **isymbuf_p)
9536 {
9537 Elf_Internal_Shdr *symtab_hdr;
9538 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9539
9540 /* Read this BFD's local symbols if we haven't done so already. */
9541 if (*isymbuf_p == NULL && symtab_hdr->sh_info != 0)
9542 {
9543 *isymbuf_p = (Elf_Internal_Sym *) symtab_hdr->contents;
9544 if (*isymbuf_p == NULL)
9545 {
9546 *isymbuf_p = bfd_elf_get_elf_syms (abfd, symtab_hdr,
9547 symtab_hdr->sh_info, 0,
9548 NULL, NULL, NULL);
9549 if (*isymbuf_p == NULL)
9550 return FALSE;
9551 }
9552 }
9553 symtab_hdr->contents = (bfd_byte *) (*isymbuf_p);
9554
9555 return TRUE;
9556 }
9557
9558 /* Range of small data. */
9559 static bfd_vma sdata_range[2][2];
9560 static bfd_vma const sdata_init_range[2] =
9561 { ACCURATE_12BIT_S1, ACCURATE_19BIT };
9562
9563 static int
9564 nds32_elf_insn_size (bfd *abfd ATTRIBUTE_UNUSED,
9565 bfd_byte *contents, bfd_vma addr)
9566 {
9567 unsigned long insn = bfd_getb32 (contents + addr);
9568
9569 if (insn & 0x80000000)
9570 return 2;
9571
9572 return 4;
9573 }
9574
9575 /* Set the gp relax range. We have to measure the safe range
9576 to do gp relaxation. */
9577
9578 static void
9579 relax_range_measurement (bfd *abfd)
9580 {
9581 asection *sec_f, *sec_b;
9582 /* For upper bound. */
9583 bfd_vma maxpgsz = get_elf_backend_data (abfd)->maxpagesize;
9584 bfd_vma align;
9585 static int decide_relax_range = 0;
9586 int i;
9587 int range_number = ARRAY_SIZE (sdata_init_range);
9588
9589 if (decide_relax_range)
9590 return;
9591 decide_relax_range = 1;
9592
9593 if (sda_rela_sec == NULL)
9594 {
9595 /* Since there is no data sections, we assume the range is page size. */
9596 for (i = 0; i < range_number; i++)
9597 {
9598 sdata_range[i][0] = sdata_init_range[i] - 0x1000;
9599 sdata_range[i][1] = sdata_init_range[i] - 0x1000;
9600 }
9601 return;
9602 }
9603
9604 /* Get the biggest alignment power after the gp located section. */
9605 sec_f = sda_rela_sec->output_section;
9606 sec_b = sec_f->next;
9607 align = 0;
9608 while (sec_b != NULL)
9609 {
9610 if ((unsigned)(1 << sec_b->alignment_power) > align)
9611 align = (1 << sec_b->alignment_power);
9612 sec_b = sec_b->next;
9613 }
9614
9615 /* I guess we can not determine the section before
9616 gp located section, so we assume the align is max page size. */
9617 for (i = 0; i < range_number; i++)
9618 {
9619 sdata_range[i][1] = sdata_init_range[i] - align;
9620 BFD_ASSERT (sdata_range[i][1] <= sdata_init_range[i]);
9621 sdata_range[i][0] = sdata_init_range[i] - maxpgsz;
9622 BFD_ASSERT (sdata_range[i][0] <= sdata_init_range[i]);
9623 }
9624 }
9625
9626 /* These are macros used to check flags encoded in r_addend.
9627 They are only used by nds32_elf_relax_section (). */
9628 #define GET_SEQ_LEN(addend) ((addend) & 0x000000ff)
9629 #define IS_1ST_CONVERT(addend) ((addend) & 0x80000000)
9630 #define IS_OPTIMIZE(addend) ((addend) & 0x40000000)
9631 #define IS_16BIT_ON(addend) ((addend) & 0x20000000)
9632
9633 static const char * unrecognized_reloc_msg =
9634 /* xgettext:c-format */
9635 N_("%pB: warning: %s points to unrecognized reloc at %#" PRIx64);
9636
9637 /* Relax LONGCALL1 relocation for nds32_elf_relax_section. */
9638
9639 static bfd_boolean
9640 nds32_elf_relax_longcall1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9641 Elf_Internal_Rela *internal_relocs, int *insn_len,
9642 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9643 Elf_Internal_Shdr *symtab_hdr)
9644 {
9645 /* There are 3 variations for LONGCALL1
9646 case 4-4-2; 16-bit on, optimize off or optimize for space
9647 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9648 ori ta, ta, lo12(symbol) ; LO12S0
9649 jral5 ta ;
9650
9651 case 4-4-4; 16-bit off, optimize don't care
9652 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9653 ori ta, ta, lo12(symbol) ; LO12S0
9654 jral ta ;
9655
9656 case 4-4-4; 16-bit on, optimize for speed
9657 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9658 ori ta, ta, lo12(symbol) ; LO12S0
9659 jral ta ;
9660 Check code for -mlong-calls output. */
9661
9662 /* Get the reloc for the address from which the register is
9663 being loaded. This reloc will tell us which function is
9664 actually being called. */
9665
9666 bfd_vma laddr;
9667 int seq_len; /* Original length of instruction sequence. */
9668 uint32_t insn;
9669 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9670 bfd_signed_vma foff;
9671 uint16_t insn16;
9672
9673 irelend = internal_relocs + sec->reloc_count;
9674 seq_len = GET_SEQ_LEN (irel->r_addend);
9675 laddr = irel->r_offset;
9676 *insn_len = seq_len;
9677
9678 hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9679 R_NDS32_HI20_RELA, laddr);
9680 lo_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9681 R_NDS32_LO12S0_ORI_RELA,
9682 laddr + 4);
9683
9684 if (hi_irelfn == irelend || lo_irelfn == irelend)
9685 {
9686 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL1",
9687 (uint64_t) irel->r_offset);
9688 return FALSE;
9689 }
9690
9691 /* Get the value of the symbol referred to by the reloc. */
9692 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
9693
9694 /* This condition only happened when symbol is undefined. */
9695 if (foff == 0
9696 || foff < -CONSERVATIVE_24BIT_S1
9697 || foff >= CONSERVATIVE_24BIT_S1)
9698 return FALSE;
9699
9700 /* Relax to: jal symbol; 25_PCREL. */
9701 /* For simplicity of coding, we are going to modify the section
9702 contents, the section relocs, and the BFD symbol table. We
9703 must tell the rest of the code not to free up this
9704 information. It would be possible to instead create a table
9705 of changes which have to be made, as is done in coff-mips.c;
9706 that would be more work, but would require less memory when
9707 the linker is run. */
9708
9709 /* Replace the long call with a jal. */
9710 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9711 R_NDS32_25_PCREL_RELA);
9712 irel->r_addend = hi_irelfn->r_addend;
9713
9714 /* We don't resolve this here but resolve it in relocate_section. */
9715 insn = INSN_JAL;
9716 bfd_putb32 (insn, contents + irel->r_offset);
9717
9718 hi_irelfn->r_info =
9719 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9720 lo_irelfn->r_info =
9721 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9722 *insn_len = 4;
9723
9724 if (seq_len & 0x2)
9725 {
9726 insn16 = NDS32_NOP16;
9727 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9728 lo_irelfn->r_info =
9729 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9730 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9731 *insn_len += 2;
9732 }
9733 return TRUE;
9734 }
9735
9736 #define CONVERT_CONDITION_CALL(insn) (((insn) & 0xffff0000) ^ 0x90000)
9737 /* Relax LONGCALL2 relocation for nds32_elf_relax_section. */
9738
9739 static bfd_boolean
9740 nds32_elf_relax_longcall2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9741 Elf_Internal_Rela *internal_relocs, int *insn_len,
9742 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9743 Elf_Internal_Shdr *symtab_hdr)
9744 {
9745 /* bltz rt, .L1 ; LONGCALL2
9746 jal symbol ; 25_PCREL
9747 .L1: */
9748
9749 /* Get the reloc for the address from which the register is
9750 being loaded. This reloc will tell us which function is
9751 actually being called. */
9752
9753 bfd_vma laddr;
9754 uint32_t insn;
9755 Elf_Internal_Rela *i1_irelfn, *cond_irelfn, *irelend;
9756 bfd_signed_vma foff;
9757
9758 irelend = internal_relocs + sec->reloc_count;
9759 laddr = irel->r_offset;
9760 i1_irelfn =
9761 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9762 R_NDS32_25_PCREL_RELA, laddr + 4);
9763
9764 if (i1_irelfn == irelend)
9765 {
9766 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL2",
9767 (uint64_t) irel->r_offset);
9768 return FALSE;
9769 }
9770
9771 insn = bfd_getb32 (contents + laddr);
9772
9773 /* Get the value of the symbol referred to by the reloc. */
9774 foff = calculate_offset (abfd, sec, i1_irelfn, isymbuf, symtab_hdr);
9775
9776 if (foff == 0
9777 || foff < -CONSERVATIVE_16BIT_S1
9778 || foff >= CONSERVATIVE_16BIT_S1)
9779 return FALSE;
9780
9781 /* Relax to bgezal rt, label ; 17_PCREL
9782 or bltzal rt, label ; 17_PCREL */
9783
9784 /* Convert to complimentary conditional call. */
9785 insn = CONVERT_CONDITION_CALL (insn);
9786
9787 /* For simplicity of coding, we are going to modify the section
9788 contents, the section relocs, and the BFD symbol table. We
9789 must tell the rest of the code not to free up this
9790 information. It would be possible to instead create a table
9791 of changes which have to be made, as is done in coff-mips.c;
9792 that would be more work, but would require less memory when
9793 the linker is run. */
9794
9795 /* Clean unnessary relocations. */
9796 i1_irelfn->r_info =
9797 ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info), R_NDS32_NONE);
9798 cond_irelfn =
9799 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9800 R_NDS32_17_PCREL_RELA, laddr);
9801 if (cond_irelfn != irelend)
9802 cond_irelfn->r_info =
9803 ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info), R_NDS32_NONE);
9804
9805 /* Replace the long call with a bgezal. */
9806 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info),
9807 R_NDS32_17_PCREL_RELA);
9808 irel->r_addend = i1_irelfn->r_addend;
9809
9810 bfd_putb32 (insn, contents + irel->r_offset);
9811
9812 *insn_len = 4;
9813 return TRUE;
9814 }
9815
9816 /* Relax LONGCALL3 relocation for nds32_elf_relax_section. */
9817
9818 static bfd_boolean
9819 nds32_elf_relax_longcall3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9820 Elf_Internal_Rela *internal_relocs, int *insn_len,
9821 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9822 Elf_Internal_Shdr *symtab_hdr)
9823 {
9824 /* There are 3 variations for LONGCALL3
9825 case 4-4-4-2; 16-bit on, optimize off or optimize for space
9826 bltz rt, $1 ; LONGCALL3
9827 sethi ta, hi20(symbol) ; HI20
9828 ori ta, ta, lo12(symbol) ; LO12S0
9829 jral5 ta ;
9830 $1
9831
9832 case 4-4-4-4; 16-bit off, optimize don't care
9833 bltz rt, $1 ; LONGCALL3
9834 sethi ta, hi20(symbol) ; HI20
9835 ori ta, ta, lo12(symbol) ; LO12S0
9836 jral ta ;
9837 $1
9838
9839 case 4-4-4-4; 16-bit on, optimize for speed
9840 bltz rt, $1 ; LONGCALL3
9841 sethi ta, hi20(symbol) ; HI20
9842 ori ta, ta, lo12(symbol) ; LO12S0
9843 jral ta ;
9844 $1 */
9845
9846 /* Get the reloc for the address from which the register is
9847 being loaded. This reloc will tell us which function is
9848 actually being called. */
9849
9850 bfd_vma laddr;
9851 int seq_len; /* Original length of instruction sequence. */
9852 uint32_t insn;
9853 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9854 bfd_signed_vma foff;
9855 uint16_t insn16;
9856
9857 irelend = internal_relocs + sec->reloc_count;
9858 seq_len = GET_SEQ_LEN (irel->r_addend);
9859 laddr = irel->r_offset;
9860 *insn_len = seq_len;
9861
9862 hi_irelfn =
9863 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9864 R_NDS32_HI20_RELA, laddr + 4);
9865 lo_irelfn =
9866 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9867 R_NDS32_LO12S0_ORI_RELA, laddr + 8);
9868
9869 if (hi_irelfn == irelend || lo_irelfn == irelend)
9870 {
9871 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL3",
9872 (uint64_t) irel->r_offset);
9873 return FALSE;
9874 }
9875
9876 /* Get the value of the symbol referred to by the reloc. */
9877 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
9878
9879 if (foff == 0
9880 || foff < -CONSERVATIVE_24BIT_S1
9881 || foff >= CONSERVATIVE_24BIT_S1)
9882 return FALSE;
9883
9884 insn = bfd_getb32 (contents + laddr);
9885 if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
9886 {
9887 /* Relax to bgezal rt, label ; 17_PCREL
9888 or bltzal rt, label ; 17_PCREL */
9889
9890 /* Convert to complimentary conditional call. */
9891 insn = CONVERT_CONDITION_CALL (insn);
9892 bfd_putb32 (insn, contents + irel->r_offset);
9893
9894 *insn_len = 4;
9895 irel->r_info =
9896 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9897 hi_irelfn->r_info =
9898 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9899 lo_irelfn->r_info =
9900 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9901
9902 cond_irelfn =
9903 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9904 R_NDS32_17_PCREL_RELA, laddr);
9905 if (cond_irelfn != irelend)
9906 {
9907 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9908 R_NDS32_17_PCREL_RELA);
9909 cond_irelfn->r_addend = hi_irelfn->r_addend;
9910 }
9911
9912 if (seq_len & 0x2)
9913 {
9914 insn16 = NDS32_NOP16;
9915 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9916 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9917 R_NDS32_INSN16);
9918 hi_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9919 insn_len += 2;
9920 }
9921 }
9922 else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
9923 {
9924 /* Relax to the following instruction sequence
9925 bltz rt, $1 ; LONGCALL2
9926 jal symbol ; 25_PCREL
9927 $1 */
9928 *insn_len = 8;
9929 insn = INSN_JAL;
9930 bfd_putb32 (insn, contents + hi_irelfn->r_offset);
9931
9932 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9933 R_NDS32_25_PCREL_RELA);
9934 irel->r_info =
9935 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL2);
9936
9937 lo_irelfn->r_info =
9938 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9939
9940 if (seq_len & 0x2)
9941 {
9942 insn16 = NDS32_NOP16;
9943 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9944 lo_irelfn->r_info =
9945 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9946 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9947 insn_len += 2;
9948 }
9949 }
9950 return TRUE;
9951 }
9952
9953 /* Relax LONGJUMP1 relocation for nds32_elf_relax_section. */
9954
9955 static bfd_boolean
9956 nds32_elf_relax_longjump1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9957 Elf_Internal_Rela *internal_relocs, int *insn_len,
9958 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9959 Elf_Internal_Shdr *symtab_hdr)
9960 {
9961 /* There are 3 variations for LONGJUMP1
9962 case 4-4-2; 16-bit bit on, optimize off or optimize for space
9963 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
9964 ori ta, ta, lo12(symbol) ; LO12S0
9965 jr5 ta ;
9966
9967 case 4-4-4; 16-bit off, optimize don't care
9968 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
9969 ori ta, ta, lo12(symbol) ; LO12S0
9970 jr ta ;
9971
9972 case 4-4-4; 16-bit on, optimize for speed
9973 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
9974 ori ta, ta, lo12(symbol) ; LO12S0
9975 jr ta ; */
9976
9977 /* Get the reloc for the address from which the register is
9978 being loaded. This reloc will tell us which function is
9979 actually being called. */
9980
9981 bfd_vma laddr;
9982 int seq_len; /* Original length of instruction sequence. */
9983 int insn16_on; /* 16-bit on/off. */
9984 uint32_t insn;
9985 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9986 bfd_signed_vma foff;
9987 uint16_t insn16;
9988 unsigned long reloc;
9989
9990 irelend = internal_relocs + sec->reloc_count;
9991 seq_len = GET_SEQ_LEN (irel->r_addend);
9992 laddr = irel->r_offset;
9993 *insn_len = seq_len;
9994 insn16_on = IS_16BIT_ON (irel->r_addend);
9995
9996 hi_irelfn =
9997 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9998 R_NDS32_HI20_RELA, laddr);
9999 lo_irelfn =
10000 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10001 R_NDS32_LO12S0_ORI_RELA, laddr + 4);
10002 if (hi_irelfn == irelend || lo_irelfn == irelend)
10003 {
10004 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP1",
10005 (uint64_t) irel->r_offset);
10006 return FALSE;
10007 }
10008
10009 /* Get the value of the symbol referred to by the reloc. */
10010 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
10011
10012 if (foff == 0
10013 || foff >= CONSERVATIVE_24BIT_S1
10014 || foff < -CONSERVATIVE_24BIT_S1)
10015 return FALSE;
10016
10017 if (insn16_on
10018 && foff >= -ACCURATE_8BIT_S1
10019 && foff < ACCURATE_8BIT_S1
10020 && (seq_len & 0x2))
10021 {
10022 /* j8 label */
10023 /* 16-bit on, but not optimized for speed. */
10024 reloc = R_NDS32_9_PCREL_RELA;
10025 insn16 = INSN_J8;
10026 bfd_putb16 (insn16, contents + irel->r_offset);
10027 *insn_len = 2;
10028 irel->r_info =
10029 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10030 }
10031 else
10032 {
10033 /* j label */
10034 reloc = R_NDS32_25_PCREL_RELA;
10035 insn = INSN_J;
10036 bfd_putb32 (insn, contents + irel->r_offset);
10037 *insn_len = 4;
10038 irel->r_info =
10039 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_INSN16);
10040 irel->r_addend = 0;
10041 }
10042
10043 hi_irelfn->r_info =
10044 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
10045 lo_irelfn->r_info =
10046 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
10047
10048 if ((seq_len & 0x2) && ((*insn_len & 2) == 0))
10049 {
10050 insn16 = NDS32_NOP16;
10051 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10052 lo_irelfn->r_info =
10053 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
10054 R_NDS32_INSN16);
10055 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10056 *insn_len += 2;
10057 }
10058 return TRUE;
10059 }
10060
10061 /* Revert condition branch. This function does not check if the input
10062 instruction is condition branch or not. */
10063
10064 static void
10065 nds32_elf_convert_branch (uint16_t insn16, uint32_t insn,
10066 uint16_t *re_insn16, uint32_t *re_insn)
10067 {
10068 uint32_t comp_insn = 0;
10069 uint16_t comp_insn16 = 0;
10070
10071 if (insn)
10072 {
10073 if (N32_OP6 (insn) == N32_OP6_BR1)
10074 {
10075 /* beqs label. */
10076 comp_insn = (insn ^ 0x4000) & 0xffffc000;
10077 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5)
10078 {
10079 /* Insn can be contracted to 16-bit implied r5. */
10080 comp_insn16 =
10081 (comp_insn & 0x4000) ? INSN_BNES38 : INSN_BEQS38;
10082 comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
10083 }
10084 }
10085 else if (N32_OP6 (insn) == N32_OP6_BR3)
10086 {
10087 /* bnec $ta, imm11, label. */
10088 comp_insn = (insn ^ 0x80000) & 0xffffff00;
10089 }
10090 else
10091 {
10092 comp_insn = (insn ^ 0x10000) & 0xffffc000;
10093 if (N32_BR2_SUB (insn) == N32_BR2_BEQZ
10094 || N32_BR2_SUB (insn) == N32_BR2_BNEZ)
10095 {
10096 if (N32_IS_RT3 (insn))
10097 {
10098 /* Insn can be contracted to 16-bit. */
10099 comp_insn16 =
10100 (comp_insn & 0x10000) ? INSN_BNEZ38 : INSN_BEQZ38;
10101 comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
10102 }
10103 else if (N32_RT5 (insn) == REG_R15)
10104 {
10105 /* Insn can be contracted to 16-bit. */
10106 comp_insn16 =
10107 (comp_insn & 0x10000) ? INSN_BNES38 : INSN_BEQS38;
10108 }
10109 }
10110 }
10111 }
10112 else
10113 {
10114 switch ((insn16 & 0xf000) >> 12)
10115 {
10116 case 0xc:
10117 /* beqz38 or bnez38 */
10118 comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
10119 comp_insn = (comp_insn16 & 0x0800) ? INSN_BNEZ : INSN_BEQZ;
10120 comp_insn |= ((comp_insn16 & 0x0700) >> 8) << 20;
10121 break;
10122
10123 case 0xd:
10124 /* beqs38 or bnes38 */
10125 comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
10126 comp_insn = (comp_insn16 & 0x0800) ? INSN_BNE : INSN_BEQ;
10127 comp_insn |= (((comp_insn16 & 0x0700) >> 8) << 20)
10128 | (REG_R5 << 15);
10129 break;
10130
10131 case 0xe:
10132 /* beqzS8 or bnezS8 */
10133 comp_insn16 = (insn16 ^ 0x0100) & 0xff00;
10134 comp_insn = (comp_insn16 & 0x0100) ? INSN_BNEZ : INSN_BEQZ;
10135 comp_insn |= REG_R15 << 20;
10136 break;
10137
10138 default:
10139 break;
10140 }
10141 }
10142 if (comp_insn && re_insn)
10143 *re_insn = comp_insn;
10144 if (comp_insn16 && re_insn16)
10145 *re_insn16 = comp_insn16;
10146 }
10147
10148 /* Relax LONGJUMP2 relocation for nds32_elf_relax_section. */
10149
10150 static bfd_boolean
10151 nds32_elf_relax_longjump2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10152 Elf_Internal_Rela *internal_relocs, int *insn_len,
10153 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10154 Elf_Internal_Shdr *symtab_hdr)
10155 {
10156 /* There are 3 variations for LONGJUMP2
10157 case 2-4; 1st insn convertible, 16-bit on,
10158 optimize off or optimize for space
10159 bnes38 rt, ra, $1 ; LONGJUMP2
10160 j label ; 25_PCREL
10161 $1:
10162
10163 case 4-4; 1st insn not convertible
10164 bne rt, ra, $1 ; LONGJUMP2
10165 j label ; 25_PCREL
10166 $1:
10167
10168 case 4-4; 1st insn convertible, 16-bit on, optimize for speed
10169 bne rt, ra, $1 ; LONGJUMP2
10170 j label ; 25_PCREL
10171 $1: */
10172
10173 /* Get the reloc for the address from which the register is
10174 being loaded. This reloc will tell us which function is
10175 actually being called. */
10176
10177 bfd_vma laddr;
10178 int seq_len; /* Original length of instruction sequence. */
10179 Elf_Internal_Rela *i2_irelfn, *cond_irelfn, *irelend;
10180 int first_size;
10181 unsigned int i;
10182 bfd_signed_vma foff;
10183 uint32_t insn, re_insn = 0;
10184 uint16_t insn16, re_insn16 = 0;
10185 unsigned long reloc, cond_reloc;
10186
10187 enum elf_nds32_reloc_type checked_types[] =
10188 { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
10189
10190 irelend = internal_relocs + sec->reloc_count;
10191 seq_len = GET_SEQ_LEN (irel->r_addend);
10192 laddr = irel->r_offset;
10193 *insn_len = seq_len;
10194 first_size = (seq_len == 6) ? 2 : 4;
10195
10196 i2_irelfn =
10197 find_relocs_at_address_addr (irel, internal_relocs,
10198 irelend, R_NDS32_25_PCREL_RELA,
10199 laddr + first_size);
10200
10201 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
10202 {
10203 cond_irelfn =
10204 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10205 checked_types[i], laddr);
10206 if (cond_irelfn != irelend)
10207 break;
10208 }
10209
10210 if (i2_irelfn == irelend || cond_irelfn == irelend)
10211 {
10212 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP2",
10213 (uint64_t) irel->r_offset);
10214 return FALSE;
10215 }
10216
10217 /* Get the value of the symbol referred to by the reloc. */
10218 foff = calculate_offset (abfd, sec, i2_irelfn, isymbuf, symtab_hdr);
10219 if (foff == 0
10220 || foff < -CONSERVATIVE_16BIT_S1
10221 || foff >= CONSERVATIVE_16BIT_S1)
10222 return FALSE;
10223
10224 /* Get the all corresponding instructions. */
10225 if (first_size == 4)
10226 {
10227 insn = bfd_getb32 (contents + laddr);
10228 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10229 }
10230 else
10231 {
10232 insn16 = bfd_getb16 (contents + laddr);
10233 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10234 }
10235
10236 if (re_insn16 && foff >= -(ACCURATE_8BIT_S1 - first_size)
10237 && foff < ACCURATE_8BIT_S1 - first_size)
10238 {
10239 if (first_size == 4)
10240 {
10241 /* Don't convert it to 16-bit now, keep this as relaxable for
10242 ``label reloc; INSN16''. */
10243
10244 /* Save comp_insn32 to buffer. */
10245 bfd_putb32 (re_insn, contents + irel->r_offset);
10246 *insn_len = 4;
10247 reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
10248 R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
10249 cond_reloc = R_NDS32_INSN16;
10250 }
10251 else
10252 {
10253 bfd_putb16 (re_insn16, contents + irel->r_offset);
10254 *insn_len = 2;
10255 reloc = R_NDS32_9_PCREL_RELA;
10256 cond_reloc = R_NDS32_NONE;
10257 }
10258 }
10259 else if (N32_OP6 (re_insn) == N32_OP6_BR1
10260 && (foff >= -(ACCURATE_14BIT_S1 - first_size)
10261 && foff < ACCURATE_14BIT_S1 - first_size))
10262 {
10263 /* beqs label ; 15_PCREL */
10264 bfd_putb32 (re_insn, contents + irel->r_offset);
10265 *insn_len = 4;
10266 reloc = R_NDS32_15_PCREL_RELA;
10267 cond_reloc = R_NDS32_NONE;
10268 }
10269 else if (N32_OP6 (re_insn) == N32_OP6_BR2
10270 && foff >= -CONSERVATIVE_16BIT_S1
10271 && foff < CONSERVATIVE_16BIT_S1)
10272 {
10273 /* beqz label ; 17_PCREL */
10274 bfd_putb32 (re_insn, contents + irel->r_offset);
10275 *insn_len = 4;
10276 reloc = R_NDS32_17_PCREL_RELA;
10277 cond_reloc = R_NDS32_NONE;
10278 }
10279 else
10280 return FALSE;
10281
10282 /* Set all relocations. */
10283 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info), reloc);
10284 irel->r_addend = i2_irelfn->r_addend;
10285
10286 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
10287 cond_reloc);
10288 cond_irelfn->r_addend = 0;
10289
10290 if ((seq_len ^ *insn_len ) & 0x2)
10291 {
10292 insn16 = NDS32_NOP16;
10293 bfd_putb16 (insn16, contents + irel->r_offset + 4);
10294 i2_irelfn->r_offset = 4;
10295 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
10296 R_NDS32_INSN16);
10297 i2_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10298 *insn_len += 2;
10299 }
10300 else
10301 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
10302 R_NDS32_NONE);
10303 return TRUE;
10304 }
10305
10306 /* Relax LONGJUMP3 relocation for nds32_elf_relax_section. */
10307
10308 static bfd_boolean
10309 nds32_elf_relax_longjump3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10310 Elf_Internal_Rela *internal_relocs, int *insn_len,
10311 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10312 Elf_Internal_Shdr *symtab_hdr)
10313 {
10314 /* There are 5 variations for LONGJUMP3
10315 case 1: 2-4-4-2; 1st insn convertible, 16-bit on,
10316 optimize off or optimize for space
10317 bnes38 rt, ra, $1 ; LONGJUMP3
10318 sethi ta, hi20(symbol) ; HI20
10319 ori ta, ta, lo12(symbol) ; LO12S0
10320 jr5 ta ;
10321 $1: ;
10322
10323 case 2: 2-4-4-2; 1st insn convertible, 16-bit on, optimize for speed
10324 bnes38 rt, ra, $1 ; LONGJUMP3
10325 sethi ta, hi20(symbol) ; HI20
10326 ori ta, ta, lo12(symbol) ; LO12S0
10327 jr5 ta ;
10328 $1: ; LABEL
10329
10330 case 3: 4-4-4-2; 1st insn not convertible, 16-bit on,
10331 optimize off or optimize for space
10332 bne rt, ra, $1 ; LONGJUMP3
10333 sethi ta, hi20(symbol) ; HI20
10334 ori ta, ta, lo12(symbol) ; LO12S0
10335 jr5 ta ;
10336 $1: ;
10337
10338 case 4: 4-4-4-4; 1st insn don't care, 16-bit off, optimize don't care
10339 16-bit off if no INSN16
10340 bne rt, ra, $1 ; LONGJUMP3
10341 sethi ta, hi20(symbol) ; HI20
10342 ori ta, ta, lo12(symbol) ; LO12S0
10343 jr ta ;
10344 $1: ;
10345
10346 case 5: 4-4-4-4; 1st insn not convertible, 16-bit on, optimize for speed
10347 16-bit off if no INSN16
10348 bne rt, ra, $1 ; LONGJUMP3
10349 sethi ta, hi20(symbol) ; HI20
10350 ori ta, ta, lo12(symbol) ; LO12S0
10351 jr ta ;
10352 $1: ; LABEL */
10353
10354 /* Get the reloc for the address from which the register is
10355 being loaded. This reloc will tell us which function is
10356 actually being called. */
10357 enum elf_nds32_reloc_type checked_types[] =
10358 { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
10359
10360 int reloc_off = 0, cond_removed = 0, convertible;
10361 bfd_vma laddr;
10362 int seq_len; /* Original length of instruction sequence. */
10363 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
10364 int first_size;
10365 unsigned int i;
10366 bfd_signed_vma foff;
10367 uint32_t insn, re_insn = 0;
10368 uint16_t insn16, re_insn16 = 0;
10369 unsigned long reloc, cond_reloc;
10370
10371 irelend = internal_relocs + sec->reloc_count;
10372 seq_len = GET_SEQ_LEN (irel->r_addend);
10373 laddr = irel->r_offset;
10374 *insn_len = seq_len;
10375
10376 convertible = IS_1ST_CONVERT (irel->r_addend);
10377
10378 if (convertible)
10379 first_size = 2;
10380 else
10381 first_size = 4;
10382
10383 /* Get all needed relocations. */
10384 hi_irelfn =
10385 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10386 R_NDS32_HI20_RELA, laddr + first_size);
10387 lo_irelfn =
10388 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10389 R_NDS32_LO12S0_ORI_RELA,
10390 laddr + first_size + 4);
10391
10392 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
10393 {
10394 cond_irelfn =
10395 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10396 checked_types[i], laddr);
10397 if (cond_irelfn != irelend)
10398 break;
10399 }
10400
10401 if (hi_irelfn == irelend
10402 || lo_irelfn == irelend
10403 || cond_irelfn == irelend)
10404 {
10405 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP3",
10406 (uint64_t) irel->r_offset);
10407 return FALSE;
10408 }
10409
10410 /* Get the value of the symbol referred to by the reloc. */
10411 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
10412
10413 if (foff == 0
10414 || foff < -CONSERVATIVE_24BIT_S1
10415 || foff >= CONSERVATIVE_24BIT_S1)
10416 return FALSE;
10417
10418 /* Get the all corresponding instructions. */
10419 if (first_size == 4)
10420 {
10421 insn = bfd_getb32 (contents + laddr);
10422 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10423 }
10424 else
10425 {
10426 insn16 = bfd_getb16 (contents + laddr);
10427 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10428 }
10429
10430 /* For simplicity of coding, we are going to modify the section
10431 contents, the section relocs, and the BFD symbol table. We
10432 must tell the rest of the code not to free up this
10433 information. It would be possible to instead create a table
10434 of changes which have to be made, as is done in coff-mips.c;
10435 that would be more work, but would require less memory when
10436 the linker is run. */
10437
10438 if (re_insn16
10439 && foff >= -ACCURATE_8BIT_S1 - first_size
10440 && foff < ACCURATE_8BIT_S1 - first_size)
10441 {
10442 if (!(seq_len & 0x2))
10443 {
10444 /* Don't convert it to 16-bit now, keep this as relaxable
10445 for ``label reloc; INSN1a''6. */
10446 /* Save comp_insn32 to buffer. */
10447 bfd_putb32 (re_insn, contents + irel->r_offset);
10448 *insn_len = 4;
10449 reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
10450 R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
10451 cond_reloc = R_NDS32_INSN16;
10452 }
10453 else
10454 {
10455 /* Not optimize for speed; convert sequence to 16-bit. */
10456 /* Save comp_insn16 to buffer. */
10457 bfd_putb16 (re_insn16, contents + irel->r_offset);
10458 *insn_len = 2;
10459 reloc = R_NDS32_9_PCREL_RELA;
10460 cond_reloc = R_NDS32_NONE;
10461 }
10462 cond_removed = 1;
10463 }
10464 else if (N32_OP6 (re_insn) == N32_OP6_BR1
10465 && (foff >= -(ACCURATE_14BIT_S1 - first_size)
10466 && foff < ACCURATE_14BIT_S1 - first_size))
10467 {
10468 /* beqs label ; 15_PCREL */
10469 bfd_putb32 (re_insn, contents + irel->r_offset);
10470 *insn_len = 4;
10471 reloc = R_NDS32_15_PCREL_RELA;
10472 cond_reloc = R_NDS32_NONE;
10473 cond_removed = 1;
10474 }
10475 else if (N32_OP6 (re_insn) == N32_OP6_BR2
10476 && foff >= -CONSERVATIVE_16BIT_S1
10477 && foff < CONSERVATIVE_16BIT_S1)
10478 {
10479 /* beqz label ; 17_PCREL */
10480 bfd_putb32 (re_insn, contents + irel->r_offset);
10481 *insn_len = 4;
10482 reloc = R_NDS32_17_PCREL_RELA;
10483 cond_reloc = R_NDS32_NONE;
10484 cond_removed = 1;
10485 }
10486 else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
10487 && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
10488 {
10489 /* Relax to one of the following 3 variations
10490
10491 case 2-4; 1st insn convertible, 16-bit on, optimize off or optimize
10492 for space
10493 bnes38 rt, $1 ; LONGJUMP2
10494 j label ; 25_PCREL
10495 $1
10496
10497 case 4-4; 1st insn not convertible, others don't care
10498 bne rt, ra, $1 ; LONGJUMP2
10499 j label ; 25_PCREL
10500 $1
10501
10502 case 4-4; 1st insn convertible, 16-bit on, optimize for speed
10503 bne rt, ra, $1 ; LONGJUMP2
10504 j label ; 25_PCREL
10505 $1 */
10506
10507 /* Offset for first instruction. */
10508
10509 /* Use j label as second instruction. */
10510 *insn_len = 4 + first_size;
10511 insn = INSN_J;
10512 bfd_putb32 (insn, contents + hi_irelfn->r_offset);
10513 reloc = R_NDS32_LONGJUMP2;
10514 cond_reloc = R_NDS32_25_PLTREL;
10515 }
10516 else
10517 return FALSE;
10518
10519 if (cond_removed == 1)
10520 {
10521 /* Set all relocations. */
10522 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
10523 irel->r_addend = hi_irelfn->r_addend;
10524
10525 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
10526 cond_reloc);
10527 cond_irelfn->r_addend = 0;
10528 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10529 R_NDS32_NONE);
10530 }
10531 else
10532 {
10533 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
10534 irel->r_addend = irel->r_addend;
10535 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10536 cond_reloc);
10537 }
10538
10539 if ((seq_len ^ *insn_len ) & 0x2)
10540 {
10541 insn16 = NDS32_NOP16;
10542 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10543 lo_irelfn->r_offset = *insn_len;
10544 lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
10545 R_NDS32_INSN16);
10546 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10547 *insn_len += 2;
10548 }
10549 else
10550 lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
10551 R_NDS32_NONE);
10552 return TRUE;
10553 }
10554
10555 /* Relax LONGCALL4 relocation for nds32_elf_relax_section. */
10556
10557 static bfd_boolean
10558 nds32_elf_relax_longcall4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10559 Elf_Internal_Rela *internal_relocs, int *insn_len,
10560 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10561 Elf_Internal_Shdr *symtab_hdr)
10562 {
10563 /* The pattern for LONGCALL4. Support for function cse.
10564 sethi ta, hi20(symbol) ; LONGCALL4/HI20
10565 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10566 jral ta ; PTR_RES/EMPTY/INSN16 */
10567
10568 bfd_vma laddr;
10569 uint32_t insn;
10570 Elf_Internal_Rela *hi_irel, *ptr_irel, *insn_irel, *em_irel, *call_irel;
10571 Elf_Internal_Rela *irelend;
10572 bfd_signed_vma foff;
10573
10574 irelend = internal_relocs + sec->reloc_count;
10575 laddr = irel->r_offset;
10576
10577 /* Get the reloc for the address from which the register is
10578 being loaded. This reloc will tell us which function is
10579 actually being called. */
10580 hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10581 R_NDS32_HI20_RELA, laddr);
10582
10583 if (hi_irel == irelend)
10584 {
10585 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL4",
10586 (uint64_t) irel->r_offset);
10587 return FALSE;
10588 }
10589
10590 /* Get the value of the symbol referred to by the reloc. */
10591 foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr);
10592
10593 /* This condition only happened when symbol is undefined. */
10594 if (foff == 0
10595 || foff < -CONSERVATIVE_24BIT_S1
10596 || foff >= CONSERVATIVE_24BIT_S1)
10597 return FALSE;
10598
10599 /* Relax to: jal symbol; 25_PCREL. */
10600 /* For simplicity of coding, we are going to modify the section
10601 contents, the section relocs, and the BFD symbol table. We
10602 must tell the rest of the code not to free up this
10603 information. It would be possible to instead create a table
10604 of changes which have to be made, as is done in coff-mips.c;
10605 that would be more work, but would require less memory when
10606 the linker is run. */
10607
10608 ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10609 R_NDS32_PTR_RESOLVED, irel->r_addend);
10610 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10611 R_NDS32_EMPTY, irel->r_addend);
10612
10613 if (ptr_irel == irelend || em_irel == irelend)
10614 {
10615 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL4",
10616 (uint64_t) irel->r_offset);
10617 return FALSE;
10618 }
10619 /* Check these is enough space to insert jal in R_NDS32_EMPTY. */
10620 insn = bfd_getb32 (contents + irel->r_addend);
10621 if (insn & 0x80000000)
10622 return FALSE;
10623
10624 /* Replace the long call with a jal. */
10625 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10626 R_NDS32_25_PCREL_RELA);
10627 ptr_irel->r_addend = 1;
10628
10629 /* We don't resolve this here but resolve it in relocate_section. */
10630 insn = INSN_JAL;
10631 bfd_putb32 (insn, contents + em_irel->r_offset);
10632
10633 irel->r_info =
10634 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10635
10636 /* If there is function cse, HI20 can not remove now. */
10637 call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10638 R_NDS32_LONGCALL4, laddr);
10639 if (call_irel == irelend)
10640 {
10641 *insn_len = 0;
10642 hi_irel->r_info =
10643 ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10644 }
10645
10646 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10647 R_NDS32_INSN16, irel->r_addend);
10648 if (insn_irel != irelend)
10649 insn_irel->r_info =
10650 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10651
10652 return TRUE;
10653 }
10654
10655 /* Relax LONGCALL5 relocation for nds32_elf_relax_section. */
10656
10657 static bfd_boolean
10658 nds32_elf_relax_longcall5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10659 Elf_Internal_Rela *internal_relocs, int *insn_len,
10660 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10661 Elf_Internal_Shdr *symtab_hdr)
10662 {
10663 /* The pattern for LONGCALL5.
10664 bltz rt, .L1 ; LONGCALL5/17_PCREL
10665 jal symbol ; 25_PCREL
10666 .L1: */
10667
10668 bfd_vma laddr;
10669 uint32_t insn;
10670 Elf_Internal_Rela *cond_irel, *irelend;
10671 bfd_signed_vma foff;
10672
10673 irelend = internal_relocs + sec->reloc_count;
10674 laddr = irel->r_offset;
10675 insn = bfd_getb32 (contents + laddr);
10676
10677 /* Get the reloc for the address from which the register is
10678 being loaded. This reloc will tell us which function is
10679 actually being called. */
10680 cond_irel =
10681 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10682 R_NDS32_25_PCREL_RELA, irel->r_addend);
10683 if (cond_irel == irelend)
10684 {
10685 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL5",
10686 (uint64_t) irel->r_offset);
10687 return FALSE;
10688 }
10689
10690 /* Get the value of the symbol referred to by the reloc. */
10691 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr);
10692
10693 if (foff == 0
10694 || foff < -CONSERVATIVE_16BIT_S1
10695 || foff >= CONSERVATIVE_16BIT_S1)
10696 return FALSE;
10697
10698 /* Relax to bgezal rt, label ; 17_PCREL
10699 or bltzal rt, label ; 17_PCREL. */
10700
10701 /* Convert to complimentary conditional call. */
10702 insn = CONVERT_CONDITION_CALL (insn);
10703
10704 /* For simplicity of coding, we are going to modify the section
10705 contents, the section relocs, and the BFD symbol table. We
10706 must tell the rest of the code not to free up this
10707 information. It would be possible to instead create a table
10708 of changes which have to be made, as is done in coff-mips.c;
10709 that would be more work, but would require less memory when
10710 the linker is run. */
10711
10712 /* Modify relocation and contents. */
10713 cond_irel->r_info =
10714 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_17_PCREL_RELA);
10715
10716 /* Replace the long call with a bgezal. */
10717 bfd_putb32 (insn, contents + cond_irel->r_offset);
10718 *insn_len = 0;
10719
10720 /* Clean unnessary relocations. */
10721 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10722
10723 cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10724 R_NDS32_17_PCREL_RELA, laddr);
10725 cond_irel->r_info =
10726 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10727
10728 return TRUE;
10729 }
10730
10731 /* Relax LONGCALL6 relocation for nds32_elf_relax_section. */
10732
10733 static bfd_boolean
10734 nds32_elf_relax_longcall6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10735 Elf_Internal_Rela *internal_relocs, int *insn_len,
10736 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10737 Elf_Internal_Shdr *symtab_hdr)
10738 {
10739 /* The pattern for LONGCALL6.
10740 bltz rt, .L1 ; LONGCALL6/17_PCREL
10741 sethi ta, hi20(symbol) ; HI20/PTR
10742 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10743 jral ta ; PTR_RES/EMPTY/INSN16
10744 .L1 */
10745
10746 bfd_vma laddr;
10747 uint32_t insn;
10748 Elf_Internal_Rela *em_irel, *cond_irel, *irelend;
10749 bfd_signed_vma foff;
10750
10751 irelend = internal_relocs + sec->reloc_count;
10752 laddr = irel->r_offset;
10753
10754 /* Get the reloc for the address from which the register is
10755 being loaded. This reloc will tell us which function is
10756 actually being called. */
10757 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10758 R_NDS32_EMPTY, irel->r_addend);
10759
10760 if (em_irel == irelend)
10761 {
10762 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL6",
10763 (uint64_t) irel->r_offset);
10764 return FALSE;
10765 }
10766
10767 /* Get the value of the symbol referred to by the reloc. */
10768 foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr);
10769
10770 if (foff == 0
10771 || foff < -CONSERVATIVE_24BIT_S1
10772 || foff >= CONSERVATIVE_24BIT_S1)
10773 return FALSE;
10774
10775 /* Check these is enough space to insert jal in R_NDS32_EMPTY. */
10776 insn = bfd_getb32 (contents + irel->r_addend);
10777 if (insn & 0x80000000)
10778 return FALSE;
10779
10780 insn = bfd_getb32 (contents + laddr);
10781 if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10782 {
10783 /* Relax to bgezal rt, label ; 17_PCREL
10784 or bltzal rt, label ; 17_PCREL. */
10785
10786 /* Convert to complimentary conditional call. */
10787 *insn_len = 0;
10788 insn = CONVERT_CONDITION_CALL (insn);
10789 bfd_putb32 (insn, contents + em_irel->r_offset);
10790
10791 em_irel->r_info =
10792 ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_17_PCREL_RELA);
10793
10794 /* Set resolved relocation. */
10795 cond_irel =
10796 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10797 R_NDS32_PTR_RESOLVED, irel->r_addend);
10798 if (cond_irel == irelend)
10799 {
10800 _bfd_error_handler (unrecognized_reloc_msg, abfd,
10801 "R_NDS32_LONGCALL6", (uint64_t) irel->r_offset);
10802 return FALSE;
10803 }
10804 cond_irel->r_addend = 1;
10805
10806 /* Clear relocations. */
10807
10808 irel->r_info =
10809 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10810
10811 cond_irel =
10812 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10813 R_NDS32_17_PCREL_RELA, laddr);
10814 if (cond_irel != irelend)
10815 cond_irel->r_info =
10816 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10817
10818 cond_irel =
10819 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10820 R_NDS32_INSN16, irel->r_addend);
10821 if (cond_irel != irelend)
10822 cond_irel->r_info =
10823 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10824
10825 }
10826 else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
10827 {
10828 /* Relax to the following instruction sequence
10829 bltz rt, .L1 ; LONGCALL2/17_PCREL
10830 jal symbol ; 25_PCREL/PTR_RES
10831 .L1 */
10832 *insn_len = 4;
10833 /* Convert instruction. */
10834 insn = INSN_JAL;
10835 bfd_putb32 (insn, contents + em_irel->r_offset);
10836
10837 /* Convert relocations. */
10838 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10839 R_NDS32_25_PCREL_RELA);
10840 irel->r_info =
10841 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL5);
10842
10843 /* Set resolved relocation. */
10844 cond_irel =
10845 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10846 R_NDS32_PTR_RESOLVED, irel->r_addend);
10847 if (cond_irel == irelend)
10848 {
10849 _bfd_error_handler (unrecognized_reloc_msg, abfd,
10850 "R_NDS32_LONGCALL6", (uint64_t) irel->r_offset);
10851 return FALSE;
10852 }
10853 cond_irel->r_addend = 1;
10854
10855 cond_irel =
10856 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10857 R_NDS32_INSN16, irel->r_addend);
10858 if (cond_irel != irelend)
10859 cond_irel->r_info =
10860 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10861 }
10862 return TRUE;
10863 }
10864
10865 /* Relax LONGJUMP4 relocation for nds32_elf_relax_section. */
10866
10867 static bfd_boolean
10868 nds32_elf_relax_longjump4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10869 Elf_Internal_Rela *internal_relocs, int *insn_len,
10870 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10871 Elf_Internal_Shdr *symtab_hdr)
10872 {
10873 /* The pattern for LONGJUMP4.
10874 sethi ta, hi20(symbol) ; LONGJUMP4/HI20
10875 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10876 jr ta ; PTR_RES/INSN16/EMPTY */
10877
10878 bfd_vma laddr;
10879 int seq_len; /* Original length of instruction sequence. */
10880 uint32_t insn;
10881 Elf_Internal_Rela *hi_irel, *ptr_irel, *em_irel, *call_irel, *irelend;
10882 bfd_signed_vma foff;
10883
10884 irelend = internal_relocs + sec->reloc_count;
10885 seq_len = GET_SEQ_LEN (irel->r_addend);
10886 laddr = irel->r_offset;
10887 *insn_len = seq_len;
10888
10889 /* Get the reloc for the address from which the register is
10890 being loaded. This reloc will tell us which function is
10891 actually being called. */
10892
10893 hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10894 R_NDS32_HI20_RELA, laddr);
10895
10896 if (hi_irel == irelend)
10897 {
10898 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP4",
10899 (uint64_t) irel->r_offset);
10900 return FALSE;
10901 }
10902
10903 /* Get the value of the symbol referred to by the reloc. */
10904 foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr);
10905
10906 if (foff == 0
10907 || foff >= CONSERVATIVE_24BIT_S1
10908 || foff < -CONSERVATIVE_24BIT_S1)
10909 return FALSE;
10910
10911 /* Convert it to "j label", it may be converted to j8 in the final
10912 pass of relaxation. Therefore, we do not consider this currently. */
10913 ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10914 R_NDS32_PTR_RESOLVED, irel->r_addend);
10915 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10916 R_NDS32_EMPTY, irel->r_addend);
10917
10918 if (ptr_irel == irelend || em_irel == irelend)
10919 {
10920 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP4",
10921 (uint64_t) irel->r_offset);
10922 return FALSE;
10923 }
10924
10925 em_irel->r_info =
10926 ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_25_PCREL_RELA);
10927 ptr_irel->r_addend = 1;
10928
10929 /* Write instruction. */
10930 insn = INSN_J;
10931 bfd_putb32 (insn, contents + em_irel->r_offset);
10932
10933 /* Clear relocations. */
10934 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10935
10936 /* If there is function cse, HI20 can not remove now. */
10937 call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10938 R_NDS32_LONGJUMP4, laddr);
10939 if (call_irel == irelend)
10940 {
10941 *insn_len = 0;
10942 hi_irel->r_info =
10943 ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10944 }
10945
10946 return TRUE;
10947 }
10948
10949 /* Relax LONGJUMP5 relocation for nds32_elf_relax_section. */
10950
10951 static bfd_boolean
10952 nds32_elf_relax_longjump5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10953 Elf_Internal_Rela *internal_relocs, int *insn_len,
10954 int *seq_len, bfd_byte *contents,
10955 Elf_Internal_Sym *isymbuf,
10956 Elf_Internal_Shdr *symtab_hdr)
10957 {
10958 /* There are 2 variations for LONGJUMP5
10959 case 2-4; 1st insn convertible, 16-bit on.
10960 bnes38 rt, ra, .L1 ; LONGJUMP5/9_PCREL/INSN16
10961 j label ; 25_PCREL/INSN16
10962 $1:
10963
10964 case 4-4; 1st insn not convertible
10965 bne rt, ra, .L1 ; LONGJUMP5/15_PCREL/INSN16
10966 j label ; 25_PCREL/INSN16
10967 .L1: */
10968
10969 bfd_vma laddr;
10970 Elf_Internal_Rela *cond_irel, *irelend;
10971 unsigned int i;
10972 bfd_signed_vma foff;
10973 uint32_t insn, re_insn = 0;
10974 uint16_t insn16, re_insn16 = 0;
10975 unsigned long reloc;
10976
10977 enum elf_nds32_reloc_type checked_types[] =
10978 { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
10979 R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
10980
10981 irelend = internal_relocs + sec->reloc_count;
10982 laddr = irel->r_offset;
10983
10984 /* Get the reloc for the address from which the register is
10985 being loaded. This reloc will tell us which function is
10986 actually being called. */
10987
10988 cond_irel =
10989 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10990 R_NDS32_25_PCREL_RELA, irel->r_addend);
10991 if (cond_irel == irelend)
10992 {
10993 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP5",
10994 (uint64_t) irel->r_offset);
10995 return FALSE;
10996 }
10997
10998 /* Get the value of the symbol referred to by the reloc. */
10999 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr);
11000
11001 if (foff == 0
11002 || foff < -CONSERVATIVE_16BIT_S1
11003 || foff >= CONSERVATIVE_16BIT_S1)
11004 return FALSE;
11005
11006 /* Get the all corresponding instructions. */
11007 insn = bfd_getb32 (contents + laddr);
11008 /* Check instruction size. */
11009 if (insn & 0x80000000)
11010 {
11011 *seq_len = 0;
11012 insn16 = insn >> 16;
11013 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
11014 }
11015 else
11016 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
11017
11018 if (N32_OP6 (re_insn) == N32_OP6_BR1
11019 && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
11020 {
11021 /* beqs label ; 15_PCREL. */
11022 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11023 reloc = R_NDS32_15_PCREL_RELA;
11024 }
11025 else if (N32_OP6 (re_insn) == N32_OP6_BR2
11026 && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
11027 {
11028 /* beqz label ; 17_PCREL. */
11029 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11030 reloc = R_NDS32_17_PCREL_RELA;
11031 }
11032 else if ( N32_OP6 (re_insn) == N32_OP6_BR3
11033 && foff >= -CONSERVATIVE_8BIT_S1 && foff < CONSERVATIVE_8BIT_S1)
11034 {
11035 /* beqc label ; 9_PCREL. */
11036 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11037 reloc = R_NDS32_WORD_9_PCREL_RELA;
11038 }
11039 else
11040 return FALSE;
11041
11042 /* Set all relocations. */
11043 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), reloc);
11044
11045 /* Clean relocations. */
11046 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11047 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
11048 {
11049 cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11050 checked_types[i], laddr);
11051 if (cond_irel != irelend)
11052 {
11053 if (*seq_len == 0
11054 && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
11055 {
11056 /* If the branch instruction is 2 byte, it cannot remove
11057 directly. Only convert it to nop16 and remove it after
11058 checking alignment issue. */
11059 insn16 = NDS32_NOP16;
11060 bfd_putb16 (insn16, contents + laddr);
11061 cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
11062 }
11063 else
11064 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11065 R_NDS32_NONE);
11066 }
11067 }
11068 *insn_len = 0;
11069
11070 return TRUE;
11071 }
11072
11073 /* Relax LONGJUMP6 relocation for nds32_elf_relax_section. */
11074
11075 static bfd_boolean
11076 nds32_elf_relax_longjump6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11077 Elf_Internal_Rela *internal_relocs, int *insn_len,
11078 int *seq_len, bfd_byte *contents,
11079 Elf_Internal_Sym *isymbuf,
11080 Elf_Internal_Shdr *symtab_hdr)
11081 {
11082 /* There are 5 variations for LONGJUMP6
11083 case : 2-4-4-4; 1st insn convertible, 16-bit on.
11084 bnes38 rt, ra, .L1 ; LONGJUMP6/15_PCREL/INSN16
11085 sethi ta, hi20(symbol) ; HI20/PTR
11086 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
11087 jr ta ; PTR_RES/INSN16/EMPTY
11088 .L1:
11089
11090 case : 4-4-4-4; 1st insn not convertible, 16-bit on.
11091 bne rt, ra, .L1 ; LONGJUMP6/15_PCREL/INSN16
11092 sethi ta, hi20(symbol) ; HI20/PTR
11093 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
11094 jr ta ; PTR_RES/INSN16/EMPTY
11095 .L1: */
11096
11097 enum elf_nds32_reloc_type checked_types[] =
11098 { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
11099 R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
11100
11101 int reloc_off = 0, cond_removed = 0;
11102 bfd_vma laddr;
11103 Elf_Internal_Rela *cond_irel, *em_irel, *irelend, *insn_irel;
11104 unsigned int i;
11105 bfd_signed_vma foff;
11106 uint32_t insn, re_insn = 0;
11107 uint16_t insn16, re_insn16 = 0;
11108 unsigned long reloc;
11109
11110 irelend = internal_relocs + sec->reloc_count;
11111 laddr = irel->r_offset;
11112
11113 /* Get the reloc for the address from which the register is
11114 being loaded. This reloc will tell us which function is
11115 actually being called. */
11116 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11117 R_NDS32_EMPTY, irel->r_addend);
11118
11119 if (em_irel == irelend)
11120 {
11121 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP6",
11122 (uint64_t) irel->r_offset);
11123 return FALSE;
11124 }
11125
11126 /* Get the value of the symbol referred to by the reloc. */
11127 foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr);
11128
11129 if (foff == 0
11130 || foff < -CONSERVATIVE_24BIT_S1
11131 || foff >= CONSERVATIVE_24BIT_S1)
11132 return FALSE;
11133
11134 insn = bfd_getb32 (contents + laddr);
11135 /* Check instruction size. */
11136 if (insn & 0x80000000)
11137 {
11138 *seq_len = 0;
11139 insn16 = insn >> 16;
11140 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
11141 }
11142 else
11143 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
11144
11145 /* For simplicity of coding, we are going to modify the section
11146 contents, the section relocs, and the BFD symbol table. We
11147 must tell the rest of the code not to free up this
11148 information. It would be possible to instead create a table
11149 of changes which have to be made, as is done in coff-mips.c;
11150 that would be more work, but would require less memory when
11151 the linker is run. */
11152
11153 if (N32_OP6 (re_insn) == N32_OP6_BR1
11154 && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
11155 {
11156 /* beqs label ; 15_PCREL. */
11157 bfd_putb32 (re_insn, contents + em_irel->r_offset);
11158 reloc = R_NDS32_15_PCREL_RELA;
11159 cond_removed = 1;
11160 }
11161 else if (N32_OP6 (re_insn) == N32_OP6_BR2
11162 && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
11163 {
11164 /* beqz label ; 17_PCREL. */
11165 bfd_putb32 (re_insn, contents + em_irel->r_offset);
11166 reloc = R_NDS32_17_PCREL_RELA;
11167 cond_removed = 1;
11168 }
11169 else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
11170 && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
11171 {
11172 /* Relax to one of the following 2 variations
11173
11174 case 2-4; 1st insn convertible, 16-bit on.
11175 bnes38 rt, ra, .L1 ; LONGJUMP5/9_PCREL/INSN16
11176 j label ; 25_PCREL/INSN16
11177 $1:
11178
11179 case 4-4; 1st insn not convertible
11180 bne rt, ra, .L1 ; LONGJUMP5/15_PCREL/INSN16
11181 j label ; 25_PCREL/INSN16
11182 .L1: */
11183
11184 /* Use j label as second instruction. */
11185 insn = INSN_J;
11186 reloc = R_NDS32_25_PCREL_RELA;
11187 bfd_putb32 (insn, contents + em_irel->r_offset);
11188 }
11189 else
11190 return FALSE;
11191
11192 /* Set all relocations. */
11193 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), reloc);
11194
11195 cond_irel =
11196 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11197 R_NDS32_PTR_RESOLVED, em_irel->r_offset);
11198 cond_irel->r_addend = 1;
11199
11200 /* Use INSN16 of first branch instruction to distinguish if keeping
11201 INSN16 of final instruction or not. */
11202 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11203 R_NDS32_INSN16, irel->r_offset);
11204 if (insn_irel == irelend)
11205 {
11206 /* Clean the final INSN16. */
11207 insn_irel =
11208 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11209 R_NDS32_INSN16, em_irel->r_offset);
11210 insn_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11211 R_NDS32_NONE);
11212 }
11213
11214 if (cond_removed == 1)
11215 {
11216 *insn_len = 0;
11217
11218 /* Clear relocations. */
11219 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11220
11221 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
11222 {
11223 cond_irel =
11224 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11225 checked_types[i], laddr);
11226 if (cond_irel != irelend)
11227 {
11228 if (*seq_len == 0
11229 && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
11230 {
11231 /* If the branch instruction is 2 byte, it cannot remove
11232 directly. Only convert it to nop16 and remove it after
11233 checking alignment issue. */
11234 insn16 = NDS32_NOP16;
11235 bfd_putb16 (insn16, contents + laddr);
11236 cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
11237 }
11238 else
11239 cond_irel->r_info =
11240 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
11241 }
11242 }
11243 }
11244 else
11245 {
11246 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11247 R_NDS32_LONGJUMP5);
11248 }
11249
11250 return TRUE;
11251 }
11252
11253 /* Relax LONGJUMP7 relocation for nds32_elf_relax_section. */
11254
11255 static bfd_boolean
11256 nds32_elf_relax_longjump7 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11257 Elf_Internal_Rela *internal_relocs, int *insn_len,
11258 int *seq_len, bfd_byte *contents,
11259 Elf_Internal_Sym *isymbuf,
11260 Elf_Internal_Shdr *symtab_hdr)
11261 {
11262 /* There are 2 variations for LONGJUMP5
11263 case 2-4; 1st insn convertible, 16-bit on.
11264 movi55 ta, imm11 ; LONGJUMP7/INSN16
11265 beq rt, ta, label ; 15_PCREL
11266
11267 case 4-4; 1st insn not convertible
11268 movi55 ta, imm11 ; LONGJUMP7/INSN16
11269 beq rt, ta, label ; 15_PCREL */
11270
11271 bfd_vma laddr;
11272 Elf_Internal_Rela *cond_irel, *irelend, *insn_irel;
11273 bfd_signed_vma foff;
11274 uint32_t insn, re_insn = 0;
11275 uint16_t insn16;
11276 uint32_t imm11;
11277
11278 irelend = internal_relocs + sec->reloc_count;
11279 laddr = irel->r_offset;
11280
11281 /* Get the reloc for the address from which the register is
11282 being loaded. This reloc will tell us which function is
11283 actually being called. */
11284
11285 cond_irel =
11286 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11287 R_NDS32_15_PCREL_RELA, irel->r_addend);
11288 if (cond_irel == irelend)
11289 {
11290 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP7",
11291 (uint64_t) irel->r_offset);
11292 return FALSE;
11293 }
11294
11295 /* Get the value of the symbol referred to by the reloc. */
11296 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr);
11297
11298 if (foff == 0
11299 || foff < -CONSERVATIVE_8BIT_S1
11300 || foff >= CONSERVATIVE_8BIT_S1)
11301 return FALSE;
11302
11303 /* Get the first instruction for its size. */
11304 insn = bfd_getb32 (contents + laddr);
11305 if (insn & 0x80000000)
11306 {
11307 *seq_len = 0;
11308 /* Get the immediate from movi55. */
11309 imm11 = N16_IMM5S (insn >> 16);
11310 }
11311 else
11312 {
11313 /* Get the immediate from movi. */
11314 imm11 = N32_IMM20S (insn);
11315 }
11316
11317 /* Get the branch instruction. */
11318 insn = bfd_getb32 (contents + irel->r_addend);
11319 /* Convert instruction to BR3. */
11320 if ((insn >> 14) & 0x1)
11321 re_insn = N32_BR3 (BNEC, N32_RT5 (insn), imm11, 0);
11322 else
11323 re_insn = N32_BR3 (BEQC, N32_RT5 (insn), imm11, 0);
11324
11325 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11326
11327 /* Set all relocations. */
11328 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11329 R_NDS32_WORD_9_PCREL_RELA);
11330
11331 /* Clean relocations. */
11332 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11333 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11334 R_NDS32_INSN16, irel->r_offset);
11335 if (insn_irel != irelend)
11336 {
11337 if (*seq_len == 0)
11338 {
11339 /* If the first insntruction is 16bit, convert it to nop16. */
11340 insn16 = NDS32_NOP16;
11341 bfd_putb16 (insn16, contents + laddr);
11342 insn_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
11343 }
11344 else
11345 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11346 R_NDS32_NONE);
11347 }
11348 *insn_len = 0;
11349
11350 return TRUE;
11351 }
11352
11353 /* We figure out and reassign the best gp value in nds32_elf_final_sda_base
11354 for each relax round. But the gp may changed dramatically and then cause
11355 the truncated to fit errors for the the converted gp instructions.
11356 Therefore, we must reserve the minimum but safe enough size to prevent it. */
11357
11358 static bfd_boolean
11359 nds32_elf_relax_guard (bfd_vma *access_addr, bfd_vma local_sda, asection *sec,
11360 Elf_Internal_Rela *irel, bfd_boolean *again,
11361 bfd_boolean init,
11362 struct elf_nds32_link_hash_table *table,
11363 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr)
11364
11365 {
11366 int offset_to_gp;
11367 static bfd_boolean sec_pass = FALSE;
11368 static asection *first_sec = NULL, *sym_sec;
11369 /* Record the number of instructions which may be removed. */
11370 static int count = 0, record_count;
11371 Elf_Internal_Sym *isym;
11372 struct elf_link_hash_entry *h = NULL;
11373 int indx;
11374 unsigned long r_symndx;
11375 bfd *abfd = sec->owner;
11376 static bfd_vma record_sda = 0;
11377 int sda_offset = 0;
11378
11379 /* Force doing relaxation when hyper-relax is high. */
11380 if (table->hyper_relax == 2)
11381 return TRUE;
11382
11383 /* Do not relax the load/store patterns for the first
11384 relax round. */
11385 if (init)
11386 {
11387 if (!first_sec)
11388 first_sec = sec;
11389 else if (first_sec == sec)
11390 {
11391 record_count = count;
11392 count = 0;
11393 sec_pass = TRUE;
11394 }
11395
11396 if (!sec_pass)
11397 *again = TRUE;
11398
11399 return TRUE;
11400 }
11401
11402 /* Generally, _SDA_BASE_ is fixed or smaller. But the large
11403 DATA_SEGMENT_ALIGN size in the linker script may make it
11404 get even bigger. */
11405 if (record_sda == 0)
11406 record_sda = local_sda;
11407 else if (local_sda > record_sda)
11408 sda_offset = local_sda - record_sda;
11409
11410 /* Assume the instruction will be removed in the best case. */
11411 count++;
11412
11413 /* We record the offset to gp for each symbol, and then check
11414 if it is changed dramatically after relaxing.
11415 (global symbol): elf32_nds32_hash_entry (h)->offset_to_gp
11416 (local symbol) : elf32_nds32_local_gp_offset (abfd)[r_symndx]. */
11417 r_symndx = ELF32_R_SYM (irel->r_info);
11418 if (r_symndx >= symtab_hdr->sh_info)
11419 {
11420 /* Global symbols. */
11421 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
11422 h = elf_sym_hashes (abfd)[indx];
11423 sym_sec = h->root.u.def.section;
11424 if (NDS32_GUARD_SEC_P (sym_sec->flags)
11425 || bfd_is_abs_section (sym_sec))
11426 {
11427 /* Forbid doing relaxation when hyper-relax is low. */
11428 if (table->hyper_relax == 0)
11429 return FALSE;
11430
11431 offset_to_gp = *access_addr - local_sda;
11432 if (elf32_nds32_hash_entry (h)->offset_to_gp == 0)
11433 elf32_nds32_hash_entry (h)->offset_to_gp = offset_to_gp;
11434 else if (abs (elf32_nds32_hash_entry (h)->offset_to_gp)
11435 < abs (offset_to_gp) - sda_offset)
11436 {
11437 /* This may cause the error, so we reserve the
11438 safe enough size for relaxing. */
11439 if (*access_addr >= local_sda)
11440 *access_addr += (record_count * 4);
11441 else
11442 *access_addr -= (record_count * 4);
11443 }
11444 return sec_pass;
11445 }
11446 }
11447 else
11448 {
11449 /* Local symbols. */
11450 if (!elf32_nds32_allocate_local_sym_info (abfd))
11451 return FALSE;
11452 isym = isymbuf + r_symndx;
11453
11454 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
11455 if (NDS32_GUARD_SEC_P (sym_sec->flags))
11456 {
11457 /* Forbid doing relaxation when hyper-relax is low. */
11458 if (table->hyper_relax == 0)
11459 return FALSE;
11460
11461 offset_to_gp = *access_addr - local_sda;
11462 if (elf32_nds32_local_gp_offset (abfd)[r_symndx] == 0)
11463 elf32_nds32_local_gp_offset (abfd)[r_symndx] = offset_to_gp;
11464 else if (abs (elf32_nds32_local_gp_offset (abfd)[r_symndx])
11465 < abs (offset_to_gp) - sda_offset)
11466 {
11467 /* This may cause the error, so we reserve the
11468 safe enough size for relaxing. */
11469 if (*access_addr >= local_sda)
11470 *access_addr += (record_count * 4);
11471 else
11472 *access_addr -= (record_count * 4);
11473 }
11474 return sec_pass;
11475 }
11476 }
11477
11478 return TRUE;
11479 }
11480
11481 #define GET_LOADSTORE_RANGE(addend) (((addend) >> 8) & 0x3f)
11482
11483 /* Relax LOADSTORE relocation for nds32_elf_relax_section. */
11484
11485 static bfd_boolean
11486 nds32_elf_relax_loadstore (struct bfd_link_info *link_info, bfd *abfd,
11487 asection *sec, Elf_Internal_Rela *irel,
11488 Elf_Internal_Rela *internal_relocs, int *insn_len,
11489 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11490 Elf_Internal_Shdr *symtab_hdr, int load_store_relax,
11491 struct elf_nds32_link_hash_table *table)
11492 {
11493 int eliminate_sethi = 0, range_type;
11494 unsigned int i;
11495 bfd_vma local_sda, laddr;
11496 int seq_len; /* Original length of instruction sequence. */
11497 uint32_t insn;
11498 Elf_Internal_Rela *hi_irelfn = NULL, *irelend;
11499 bfd_vma access_addr = 0;
11500 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
11501 struct elf_link_hash_entry *h = NULL;
11502 int indx;
11503 enum elf_nds32_reloc_type checked_types[] =
11504 { R_NDS32_HI20_RELA, R_NDS32_GOT_HI20,
11505 R_NDS32_GOTPC_HI20, R_NDS32_GOTOFF_HI20,
11506 R_NDS32_PLTREL_HI20, R_NDS32_PLT_GOTREL_HI20,
11507 R_NDS32_TLS_LE_HI20
11508 };
11509
11510 irelend = internal_relocs + sec->reloc_count;
11511 seq_len = GET_SEQ_LEN (irel->r_addend);
11512 laddr = irel->r_offset;
11513 *insn_len = seq_len;
11514
11515 /* Get the high part relocation. */
11516 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
11517 {
11518 hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11519 checked_types[i], laddr);
11520 if (hi_irelfn != irelend)
11521 break;
11522 }
11523
11524 if (hi_irelfn == irelend)
11525 {
11526 /* Not R_NDS32_HI20_RELA. */
11527 if (i != 0)
11528 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LOADSTORE",
11529 (uint64_t) irel->r_offset);
11530 return FALSE;
11531 }
11532
11533 range_type = GET_LOADSTORE_RANGE (irel->r_addend);
11534 nds32_elf_final_sda_base (sec->output_section->owner,
11535 link_info, &local_sda, FALSE);
11536
11537 switch (ELF32_R_TYPE (hi_irelfn->r_info))
11538 {
11539 case R_NDS32_HI20_RELA:
11540 insn = bfd_getb32 (contents + laddr);
11541 access_addr =
11542 calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
11543
11544 if (ELF32_R_SYM (hi_irelfn->r_info) >= symtab_hdr->sh_info)
11545 {
11546 indx = ELF32_R_SYM (hi_irelfn->r_info) - symtab_hdr->sh_info;
11547 h = elf_sym_hashes (abfd)[indx];
11548 }
11549
11550 /* Try movi. */
11551 if (range_type == NDS32_LOADSTORE_IMM
11552 && access_addr < CONSERVATIVE_20BIT
11553 && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
11554 {
11555 eliminate_sethi = 1;
11556 break;
11557 }
11558
11559 if (h && strcmp (h->root.root.string, FP_BASE_NAME) == 0)
11560 {
11561 eliminate_sethi = 1;
11562 break;
11563 }
11564 else if (!nds32_elf_relax_guard (&access_addr, local_sda, sec, hi_irelfn,
11565 NULL, FALSE, table, isymbuf, symtab_hdr))
11566 return FALSE;
11567
11568 if (!load_store_relax)
11569 return FALSE;
11570
11571 /* Case for set gp register. */
11572 if (N32_RT5 (insn) == REG_GP)
11573 return FALSE;
11574
11575 if (range_type == NDS32_LOADSTORE_FLOAT_S
11576 || range_type == NDS32_LOADSTORE_FLOAT_D)
11577 {
11578 range_l = sdata_range[0][0];
11579 range_h = sdata_range[0][1];
11580 }
11581 else
11582 {
11583 range_l = sdata_range[1][0];
11584 range_h = sdata_range[1][1];
11585 }
11586 break;
11587
11588 default:
11589 return FALSE;
11590 }
11591
11592 /* Delete sethi instruction. */
11593 if (eliminate_sethi == 1
11594 || (local_sda <= access_addr && (access_addr - local_sda) < range_h)
11595 || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
11596 {
11597 hi_irelfn->r_info =
11598 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
11599 irel->r_info =
11600 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11601 *insn_len = 0;
11602 return TRUE;
11603 }
11604
11605 return FALSE;
11606 }
11607
11608 /* Relax LO12 relocation for nds32_elf_relax_section. */
11609
11610 static void
11611 nds32_elf_relax_lo12 (struct bfd_link_info *link_info, bfd *abfd,
11612 asection *sec, Elf_Internal_Rela *irel,
11613 Elf_Internal_Rela *internal_relocs, bfd_byte *contents,
11614 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr,
11615 struct elf_nds32_link_hash_table *table)
11616 {
11617 uint32_t insn;
11618 bfd_vma local_sda, laddr;
11619 unsigned long reloc;
11620 bfd_vma access_addr;
11621 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
11622 Elf_Internal_Rela *irelfn = NULL, *irelend;
11623 struct elf_link_hash_entry *h = NULL;
11624 int indx;
11625
11626 /* For SDA base relative relaxation. */
11627 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11628 &local_sda, FALSE);
11629
11630 irelend = internal_relocs + sec->reloc_count;
11631 laddr = irel->r_offset;
11632 insn = bfd_getb32 (contents + laddr);
11633
11634 if (!is_sda_access_insn (insn) && N32_OP6 (insn) != N32_OP6_ORI)
11635 return;
11636
11637 access_addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11638
11639 if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
11640 {
11641 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
11642 h = elf_sym_hashes (abfd)[indx];
11643 }
11644
11645 /* Try movi. */
11646 if (N32_OP6 (insn) == N32_OP6_ORI && access_addr < CONSERVATIVE_20BIT
11647 && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
11648 {
11649 reloc = R_NDS32_20_RELA;
11650 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11651 insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
11652 bfd_putb32 (insn, contents + laddr);
11653 }
11654 else
11655 {
11656 if (h && strcmp (h->root.root.string, FP_BASE_NAME) == 0)
11657 {
11658 /* Fall through. */
11659 }
11660 else if (!nds32_elf_relax_guard (&access_addr, local_sda, sec, irel, NULL,
11661 FALSE, table, isymbuf, symtab_hdr))
11662 return;
11663
11664 range_l = sdata_range[1][0];
11665 range_h = sdata_range[1][1];
11666 switch (ELF32_R_TYPE (irel->r_info))
11667 {
11668 case R_NDS32_LO12S0_RELA:
11669 reloc = R_NDS32_SDA19S0_RELA;
11670 break;
11671 case R_NDS32_LO12S1_RELA:
11672 reloc = R_NDS32_SDA18S1_RELA;
11673 break;
11674 case R_NDS32_LO12S2_RELA:
11675 reloc = R_NDS32_SDA17S2_RELA;
11676 break;
11677 case R_NDS32_LO12S2_DP_RELA:
11678 range_l = sdata_range[0][0];
11679 range_h = sdata_range[0][1];
11680 reloc = R_NDS32_SDA12S2_DP_RELA;
11681 break;
11682 case R_NDS32_LO12S2_SP_RELA:
11683 range_l = sdata_range[0][0];
11684 range_h = sdata_range[0][1];
11685 reloc = R_NDS32_SDA12S2_SP_RELA;
11686 break;
11687 default:
11688 return;
11689 }
11690
11691 /* There are range_h and range_l because linker has to promise
11692 all sections move cross one page together. */
11693 if ((local_sda <= access_addr && (access_addr - local_sda) < range_h)
11694 || (local_sda > access_addr && (local_sda - access_addr) <= range_l)
11695 || (h && strcmp (h->root.root.string, FP_BASE_NAME) == 0))
11696 {
11697 if (N32_OP6 (insn) == N32_OP6_ORI && N32_RT5 (insn) == REG_GP)
11698 {
11699 /* Maybe we should add R_NDS32_INSN16 reloc type here
11700 or manually do some optimization. sethi can't be
11701 eliminated when updating $gp so the relative ori
11702 needs to be preserved. */
11703 return;
11704 }
11705 if (!turn_insn_to_sda_access (insn, ELF32_R_TYPE (irel->r_info),
11706 &insn))
11707 return;
11708 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11709 bfd_putb32 (insn, contents + laddr);
11710
11711 irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11712 R_NDS32_INSN16);
11713 /* SDA17 must keep INSN16 for converting fp_as_gp. */
11714 if (irelfn != irelend && reloc != R_NDS32_SDA17S2_RELA)
11715 irelfn->r_info =
11716 ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_NDS32_NONE);
11717
11718 }
11719 }
11720 return;
11721 }
11722
11723 /* Relax PTR relocation for nds32_elf_relax_section. */
11724
11725 static bfd_boolean
11726 nds32_elf_relax_ptr (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11727 Elf_Internal_Rela *internal_relocs, int *insn_len,
11728 int *seq_len, bfd_byte *contents)
11729 {
11730 Elf_Internal_Rela *ptr_irel, *irelend, *count_irel, *re_irel;
11731
11732 irelend = internal_relocs + sec->reloc_count;
11733
11734 re_irel =
11735 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11736 R_NDS32_PTR_RESOLVED, irel->r_addend);
11737
11738 if (re_irel == irelend)
11739 {
11740 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_PTR",
11741 (uint64_t) irel->r_offset);
11742 return FALSE;
11743 }
11744
11745 if (re_irel->r_addend != 1)
11746 return FALSE;
11747
11748 /* Pointed target is relaxed and no longer needs this void *,
11749 change the type to NONE. */
11750 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11751
11752 /* Find PTR_COUNT to decide remove it or not. If PTR_COUNT does
11753 not exist, it means only count 1 and remove it directly. */
11754 /* TODO: I hope we can obsolate R_NDS32_COUNT in the future. */
11755 count_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11756 R_NDS32_PTR_COUNT);
11757 ptr_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11758 R_NDS32_PTR);
11759 if (count_irel != irelend)
11760 {
11761 if (--count_irel->r_addend > 0)
11762 return FALSE;
11763 }
11764
11765 if (ptr_irel != irelend)
11766 return FALSE;
11767
11768 /* If the PTR_COUNT is already 0, remove current instruction. */
11769 *seq_len = nds32_elf_insn_size (abfd, contents, irel->r_offset);
11770 *insn_len = 0;
11771 return TRUE;
11772 }
11773
11774 /* Relax LWC relocation for nds32_elf_relax_section. */
11775
11776 static void
11777 nds32_elf_relax_flsi (struct bfd_link_info *link_info, bfd *abfd,
11778 asection *sec, Elf_Internal_Rela *irel,
11779 Elf_Internal_Rela *internal_relocs,
11780 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11781 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11782 {
11783 /* Pattern:
11784 sethi ra, hi20(symbol) ; HI20/LOADSTORE
11785 ori ra, ra, lo12(symbol) ; LO12S0/PTR/PTR/.../INSN16
11786 flsi fsa, [ra + offset1] ; LSI/PTR_RESOLVED/INSN16
11787 flsi fsb, [ra + offset2] ; LSI/PTR_RESOLVED/INSN16
11788 ... */
11789
11790 uint32_t insn;
11791 bfd_vma local_sda, laddr;
11792 unsigned long reloc;
11793 bfd_vma access_addr, flsi_offset;
11794 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
11795 Elf_Internal_Rela *irelend, *re_irel;
11796 unsigned int opcode;
11797
11798 irelend = internal_relocs + sec->reloc_count;
11799 laddr = irel->r_offset;
11800 insn = bfd_getb32 (contents + laddr);
11801
11802 if ((insn & 0x80000000) || !is_sda_access_insn (insn))
11803 return;
11804
11805 /* Can not do relaxation for bi format. */
11806 if ((insn & 0x1000))
11807 return;
11808
11809 /* Only deal with flsi, fssi, fldi, fsdi, so far. */
11810 opcode = N32_OP6 (insn);
11811 if ((opcode == N32_OP6_LWC) || (opcode == N32_OP6_SWC))
11812 reloc = R_NDS32_SDA12S2_SP_RELA;
11813 else if ((opcode == N32_OP6_LDC) || (opcode == N32_OP6_SDC))
11814 reloc = R_NDS32_SDA12S2_DP_RELA;
11815 else
11816 return;
11817
11818 re_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11819 R_NDS32_PTR_RESOLVED);
11820 if (re_irel == irelend)
11821 {
11822 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LSI",
11823 (uint64_t) irel->r_offset);
11824 return;
11825 }
11826
11827 /* For SDA base relative relaxation. */
11828 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11829 &local_sda, FALSE);
11830 access_addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11831 flsi_offset = (insn & 0xfff) << 2;
11832 access_addr += flsi_offset;
11833 range_l = sdata_range[0][0];
11834 range_h = sdata_range[0][1];
11835
11836 if ((local_sda <= access_addr && (access_addr - local_sda) < range_h)
11837 || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
11838 {
11839 /* Turn flsi instruction into sda access format. */
11840 insn = (insn & 0x7ff07000) | (REG_GP << 15);
11841
11842 /* Add relocation type to flsi. */
11843 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11844 irel->r_addend += flsi_offset;
11845 bfd_putb32 (insn, contents + re_irel->r_offset);
11846
11847 re_irel->r_addend |= 1;
11848 *again = TRUE;
11849 }
11850 }
11851
11852 static bfd_boolean
11853 nds32_relax_adjust_label (bfd *abfd, asection *sec,
11854 Elf_Internal_Rela *internal_relocs,
11855 bfd_byte *contents,
11856 nds32_elf_blank_t **relax_blank_list,
11857 int optimize, int opt_size)
11858 {
11859 /* This code block is used to adjust 4-byte alignment by relax a pair
11860 of instruction a time.
11861
11862 It recognizes three types of relocations.
11863 1. R_NDS32_LABEL - a alignment.
11864 2. R_NDS32_INSN16 - relax a 32-bit instruction to 16-bit.
11865 3. is_16bit_NOP () - remove a 16-bit instruction. */
11866
11867 /* TODO: It seems currently implementation only support 4-byte alignment.
11868 We should handle any-alignment. */
11869
11870 Elf_Internal_Rela *insn_rel = NULL, *label_rel = NULL, *irel;
11871 Elf_Internal_Rela *tmp_rel, *tmp2_rel = NULL;
11872 Elf_Internal_Rela rel_temp;
11873 Elf_Internal_Rela *irelend;
11874 bfd_vma address;
11875 uint16_t insn16;
11876
11877 /* Checking for branch relaxation relies on the relocations to
11878 be sorted on 'r_offset'. This is not guaranteed so we must sort. */
11879 nds32_insertion_sort (internal_relocs, sec->reloc_count,
11880 sizeof (Elf_Internal_Rela), compar_reloc);
11881
11882 irelend = internal_relocs + sec->reloc_count;
11883
11884 /* Force R_NDS32_LABEL before R_NDS32_INSN16. */
11885 /* FIXME: Can we generate the right order in assembler?
11886 So we don't have to swapping them here. */
11887
11888 for (label_rel = internal_relocs, insn_rel = internal_relocs;
11889 label_rel < irelend; label_rel++)
11890 {
11891 if (ELF32_R_TYPE (label_rel->r_info) != R_NDS32_LABEL)
11892 continue;
11893
11894 /* Find the first reloc has the same offset with label_rel. */
11895 while (insn_rel < irelend && insn_rel->r_offset < label_rel->r_offset)
11896 insn_rel++;
11897
11898 for (;insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset;
11899 insn_rel++)
11900 /* Check if there were R_NDS32_INSN16 and R_NDS32_LABEL at the same
11901 address. */
11902 if (ELF32_R_TYPE (insn_rel->r_info) == R_NDS32_INSN16)
11903 break;
11904
11905 if (insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset
11906 && insn_rel < label_rel)
11907 {
11908 /* Swap the two reloc if the R_NDS32_INSN16 is
11909 before R_NDS32_LABEL. */
11910 memcpy (&rel_temp, insn_rel, sizeof (Elf_Internal_Rela));
11911 memcpy (insn_rel, label_rel, sizeof (Elf_Internal_Rela));
11912 memcpy (label_rel, &rel_temp, sizeof (Elf_Internal_Rela));
11913 }
11914 }
11915
11916 label_rel = NULL;
11917 insn_rel = NULL;
11918 /* If there were a sequence of R_NDS32_LABEL end up with .align 2
11919 or higher, remove other R_NDS32_LABEL with lower alignment.
11920 If an R_NDS32_INSN16 in between R_NDS32_LABELs must be converted,
11921 then the R_NDS32_LABEL sequence is broke. */
11922 for (tmp_rel = internal_relocs; tmp_rel < irelend; tmp_rel++)
11923 {
11924 if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_LABEL)
11925 {
11926 if (label_rel == NULL)
11927 {
11928 if (tmp_rel->r_addend < 2)
11929 label_rel = tmp_rel;
11930 continue;
11931 }
11932 else if (tmp_rel->r_addend > 1)
11933 {
11934 /* Remove all LABEL relocation from label_rel to tmp_rel
11935 including relocations with same offset as tmp_rel. */
11936 for (tmp2_rel = label_rel; tmp2_rel < tmp_rel; tmp2_rel++)
11937 {
11938 if (tmp2_rel->r_offset == tmp_rel->r_offset)
11939 break;
11940
11941 if (ELF32_R_TYPE (tmp2_rel->r_info) == R_NDS32_LABEL
11942 && tmp2_rel->r_addend < 2)
11943 tmp2_rel->r_info =
11944 ELF32_R_INFO (ELF32_R_SYM (tmp2_rel->r_info),
11945 R_NDS32_NONE);
11946 }
11947 label_rel = NULL;
11948 }
11949 }
11950 else if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16 && label_rel)
11951 {
11952 /* A new INSN16 which can be converted, so clear label_rel. */
11953 if (is_convert_32_to_16 (abfd, sec, tmp_rel, internal_relocs,
11954 irelend, &insn16)
11955 || is_16bit_NOP (abfd, sec, tmp_rel))
11956 label_rel = NULL;
11957 }
11958 }
11959
11960 label_rel = NULL;
11961 insn_rel = NULL;
11962 /* Optimized for speed and nothing has not been relaxed.
11963 It's time to align labels.
11964 We may convert a 16-bit instruction right before a label to
11965 32-bit, in order to align the label if necessary
11966 all reloc entries has been sorted by r_offset. */
11967 for (irel = internal_relocs;
11968 irel < irelend && irel->r_offset < sec->size; irel++)
11969 {
11970 if (ELF32_R_TYPE (irel->r_info) != R_NDS32_INSN16
11971 && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL)
11972 continue;
11973
11974 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_INSN16)
11975 {
11976 /* A new INSN16 found, resize the old one. */
11977 if (is_convert_32_to_16
11978 (abfd, sec, irel, internal_relocs, irelend, &insn16)
11979 || is_16bit_NOP (abfd, sec, irel))
11980 {
11981 if (insn_rel)
11982 {
11983 /* Previous INSN16 reloc exists, reduce its
11984 size to 16-bit. */
11985 if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
11986 irelend, &insn16))
11987 {
11988 nds32_elf_write_16 (abfd, contents, insn_rel,
11989 internal_relocs, irelend, insn16);
11990
11991 if (!insert_nds32_elf_blank_recalc_total
11992 (relax_blank_list, insn_rel->r_offset + 2, 2))
11993 return FALSE;
11994 }
11995 else if (is_16bit_NOP (abfd, sec, insn_rel))
11996 {
11997 if (!insert_nds32_elf_blank_recalc_total
11998 (relax_blank_list, insn_rel->r_offset, 2))
11999 return FALSE;
12000 }
12001 insn_rel->r_info =
12002 ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info), R_NDS32_NONE);
12003 }
12004 /* Save the new one for later use. */
12005 insn_rel = irel;
12006 }
12007 else
12008 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
12009 R_NDS32_NONE);
12010 }
12011 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL)
12012 {
12013 /* Search for label. */
12014 int force_relax = 0;
12015
12016 /* Label on 16-bit instruction or optimization
12017 needless, just reset this reloc. */
12018 insn16 = bfd_getb16 (contents + irel->r_offset);
12019 if ((irel->r_addend & 0x1f) < 2 && (!optimize || (insn16 & 0x8000)))
12020 {
12021 irel->r_info =
12022 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
12023 continue;
12024 }
12025
12026 address =
12027 irel->r_offset - get_nds32_elf_blank_total (relax_blank_list,
12028 irel->r_offset, 1);
12029
12030 if (!insn_rel)
12031 {
12032 /* Check if there is case which can not be aligned. */
12033 if (irel->r_addend == 2 && address & 0x2)
12034 return FALSE;
12035 continue;
12036 }
12037
12038 /* Try to align this label. */
12039
12040 if ((irel->r_addend & 0x1f) < 2)
12041 {
12042 /* Check if there is a INSN16 at the same address.
12043 Label_rel always seats before insn_rel after
12044 our sort. */
12045
12046 /* Search for INSN16 at LABEL location. If INSN16 is at
12047 same location and this LABEL alignment is lower than 2,
12048 the INSN16 can be converted to 2-byte. */
12049 for (tmp_rel = irel;
12050 tmp_rel < irelend && tmp_rel->r_offset == irel->r_offset;
12051 tmp_rel++)
12052 {
12053 if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16
12054 && (is_convert_32_to_16
12055 (abfd, sec, tmp_rel, internal_relocs,
12056 irelend, &insn16)
12057 || is_16bit_NOP (abfd, sec, tmp_rel)))
12058 {
12059 force_relax = 1;
12060 break;
12061 }
12062 }
12063 }
12064
12065 if (force_relax || irel->r_addend == 1 || address & 0x2)
12066 {
12067 /* Label not aligned. */
12068 /* Previous reloc exists, reduce its size to 16-bit. */
12069 if (is_convert_32_to_16 (abfd, sec, insn_rel,
12070 internal_relocs, irelend, &insn16))
12071 {
12072 nds32_elf_write_16 (abfd, contents, insn_rel,
12073 internal_relocs, irelend, insn16);
12074
12075 if (!insert_nds32_elf_blank_recalc_total
12076 (relax_blank_list, insn_rel->r_offset + 2, 2))
12077 return FALSE;
12078 }
12079 else if (is_16bit_NOP (abfd, sec, insn_rel))
12080 {
12081 if (!insert_nds32_elf_blank_recalc_total
12082 (relax_blank_list, insn_rel->r_offset, 2))
12083 return FALSE;
12084 }
12085
12086 }
12087 /* INSN16 reloc is used. */
12088 insn_rel = NULL;
12089 }
12090 }
12091
12092 address =
12093 sec->size - get_nds32_elf_blank_total (relax_blank_list, sec->size, 0);
12094 if (insn_rel && (address & 0x2 || opt_size))
12095 {
12096 if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
12097 irelend, &insn16))
12098 {
12099 nds32_elf_write_16 (abfd, contents, insn_rel, internal_relocs,
12100 irelend, insn16);
12101 if (!insert_nds32_elf_blank_recalc_total
12102 (relax_blank_list, insn_rel->r_offset + 2, 2))
12103 return FALSE;
12104 insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
12105 R_NDS32_NONE);
12106 }
12107 else if (is_16bit_NOP (abfd, sec, insn_rel))
12108 {
12109 if (!insert_nds32_elf_blank_recalc_total
12110 (relax_blank_list, insn_rel->r_offset, 2))
12111 return FALSE;
12112 insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
12113 R_NDS32_NONE);
12114 }
12115 }
12116 insn_rel = NULL;
12117 return TRUE;
12118 }
12119
12120 static bfd_boolean
12121 nds32_elf_relax_section (bfd *abfd, asection *sec,
12122 struct bfd_link_info *link_info, bfd_boolean *again)
12123 {
12124 nds32_elf_blank_t *relax_blank_list = NULL;
12125 Elf_Internal_Shdr *symtab_hdr;
12126 Elf_Internal_Rela *internal_relocs;
12127 Elf_Internal_Rela *irel;
12128 Elf_Internal_Rela *irelend;
12129 Elf_Internal_Sym *isymbuf = NULL;
12130 bfd_byte *contents = NULL;
12131 bfd_boolean result = TRUE;
12132 int optimize = 0;
12133 int opt_size = 0;
12134 uint32_t insn;
12135 uint16_t insn16;
12136
12137 /* Target dependnet option. */
12138 struct elf_nds32_link_hash_table *table;
12139 int load_store_relax;
12140
12141 relax_blank_list = NULL;
12142
12143 *again = FALSE;
12144
12145 /* Nothing to do for
12146 * relocatable link or
12147 * non-relocatable section or
12148 * non-code section or
12149 * empty content or
12150 * no reloc entry. */
12151 if (bfd_link_relocatable (link_info)
12152 || (sec->flags & SEC_RELOC) == 0
12153 || (sec->flags & SEC_EXCLUDE) != 0
12154 || (sec->flags & SEC_CODE) == 0
12155 || sec->size == 0
12156 || sec->reloc_count == 0)
12157 return TRUE;
12158
12159 /* 09.12.11 Workaround. */
12160 /* We have to adjust align for R_NDS32_LABEL if needed.
12161 The adjust approach only can fix 2-byte align once. */
12162 if (sec->alignment_power > 2)
12163 return TRUE;
12164
12165 /* Do TLS model conversion once at first. */
12166 nds32_elf_unify_tls_model (abfd, sec, contents, link_info);
12167
12168 /* The optimization type to do. */
12169
12170 table = nds32_elf_hash_table (link_info);
12171
12172 /* Save the first section for abs symbol relaxation.
12173 This is used for checking gp relaxation in the
12174 nds32_elf_relax_loadstore and nds32_elf_relax_lo12. */
12175 nds32_elf_relax_guard (NULL, 0, sec, NULL, again, TRUE,
12176 table, NULL, NULL);
12177
12178 /* The begining of general relaxation. */
12179
12180 if (is_SDA_BASE_set == 0)
12181 {
12182 bfd_vma gp;
12183 is_SDA_BASE_set = 1;
12184 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
12185 &gp, FALSE);
12186 relax_range_measurement (abfd);
12187 }
12188
12189 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12190 /* Relocations MUST be kept in memory, because relaxation adjust them. */
12191 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
12192 TRUE /* keep_memory */);
12193 if (internal_relocs == NULL)
12194 goto error_return;
12195
12196 irelend = internal_relocs + sec->reloc_count;
12197 irel = find_relocs_at_address (internal_relocs, internal_relocs,
12198 irelend, R_NDS32_RELAX_ENTRY);
12199
12200 if (irel == irelend)
12201 return TRUE;
12202
12203 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
12204 {
12205 if (irel->r_addend & R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG)
12206 return TRUE;
12207
12208 if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FLAG)
12209 optimize = 1;
12210
12211 if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FOR_SPACE_FLAG)
12212 opt_size = 1;
12213 }
12214
12215 load_store_relax = table->load_store_relax;
12216
12217 /* Get symbol table and section content. */
12218 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12219 || !nds32_get_local_syms (abfd, sec, &isymbuf))
12220 goto error_return;
12221
12222 /* Do relax loop only when finalize is not done.
12223 Take care of relaxable relocs except INSN16. */
12224 for (irel = internal_relocs; irel < irelend; irel++)
12225 {
12226 int seq_len; /* Original length of instruction sequence. */
12227 int insn_len = 0; /* Final length of instruction sequence. */
12228 bfd_boolean removed;
12229
12230 insn = 0;
12231 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
12232 && (irel->r_addend & 0x1f) >= 2)
12233 optimize = 1;
12234
12235 /* Relocation Types
12236 R_NDS32_LONGCALL1 53
12237 R_NDS32_LONGCALL2 54
12238 R_NDS32_LONGCALL3 55
12239 R_NDS32_LONGJUMP1 56
12240 R_NDS32_LONGJUMP2 57
12241 R_NDS32_LONGJUMP3 58
12242 R_NDS32_LOADSTORE 59 */
12243 if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL1
12244 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LOADSTORE)
12245 seq_len = GET_SEQ_LEN (irel->r_addend);
12246
12247 /* Relocation Types
12248 R_NDS32_LONGCALL4 107
12249 R_NDS32_LONGCALL5 108
12250 R_NDS32_LONGCALL6 109
12251 R_NDS32_LONGJUMP4 110
12252 R_NDS32_LONGJUMP5 111
12253 R_NDS32_LONGJUMP6 112
12254 R_NDS32_LONGJUMP7 113 */
12255 else if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL4
12256 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LONGJUMP7)
12257 seq_len = 4;
12258
12259 /* Relocation Types
12260 R_NDS32_LO12S0_RELA 30
12261 R_NDS32_LO12S1_RELA 29
12262 R_NDS32_LO12S2_RELA 28
12263 R_NDS32_LO12S2_SP_RELA 71
12264 R_NDS32_LO12S2_DP_RELA 70
12265 R_NDS32_GOT_LO12 46
12266 R_NDS32_GOTOFF_LO12 50
12267 R_NDS32_PLTREL_LO12 65
12268 R_NDS32_PLT_GOTREL_LO12 67
12269 R_NDS32_17IFC_PCREL_RELA 96
12270 R_NDS32_GOT_SUFF 193
12271 R_NDS32_GOTOFF_SUFF 194
12272 R_NDS32_PLT_GOT_SUFF 195
12273 R_NDS32_MULCALL_SUFF 196
12274 R_NDS32_PTR 197 */
12275 else if ((ELF32_R_TYPE (irel->r_info) <= R_NDS32_LO12S0_RELA
12276 && ELF32_R_TYPE (irel->r_info) >= R_NDS32_LO12S2_RELA)
12277 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_SP_RELA
12278 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_DP_RELA
12279 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12
12280 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12
12281 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12
12282 || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLTREL_LO12
12283 || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12
12284 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_GOT_SUFF
12285 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_PTR)
12286 || ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12287 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LO12
12288 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_ADD
12289 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LS
12290 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LSI)
12291 seq_len = 0;
12292 else
12293 continue;
12294
12295 insn_len = seq_len;
12296 removed = FALSE;
12297
12298 switch (ELF32_R_TYPE (irel->r_info))
12299 {
12300 case R_NDS32_LONGCALL1:
12301 removed = nds32_elf_relax_longcall1 (abfd, sec, irel, internal_relocs,
12302 &insn_len, contents, isymbuf,
12303 symtab_hdr);
12304 break;
12305 case R_NDS32_LONGCALL2:
12306 removed = nds32_elf_relax_longcall2 (abfd, sec, irel, internal_relocs,
12307 &insn_len, contents, isymbuf,
12308 symtab_hdr);
12309 break;
12310 case R_NDS32_LONGCALL3:
12311 removed = nds32_elf_relax_longcall3 (abfd, sec, irel, internal_relocs,
12312 &insn_len, contents, isymbuf,
12313 symtab_hdr);
12314 break;
12315 case R_NDS32_LONGJUMP1:
12316 removed = nds32_elf_relax_longjump1 (abfd, sec, irel, internal_relocs,
12317 &insn_len, contents, isymbuf,
12318 symtab_hdr);
12319 break;
12320 case R_NDS32_LONGJUMP2:
12321 removed = nds32_elf_relax_longjump2 (abfd, sec, irel, internal_relocs,
12322 &insn_len, contents, isymbuf,
12323 symtab_hdr);
12324 break;
12325 case R_NDS32_LONGJUMP3:
12326 removed = nds32_elf_relax_longjump3 (abfd, sec, irel, internal_relocs,
12327 &insn_len, contents, isymbuf,
12328 symtab_hdr);
12329 break;
12330 case R_NDS32_LONGCALL4:
12331 removed = nds32_elf_relax_longcall4 (abfd, sec, irel, internal_relocs,
12332 &insn_len, contents, isymbuf,
12333 symtab_hdr);
12334 break;
12335 case R_NDS32_LONGCALL5:
12336 removed = nds32_elf_relax_longcall5 (abfd, sec, irel, internal_relocs,
12337 &insn_len, contents, isymbuf,
12338 symtab_hdr);
12339 break;
12340 case R_NDS32_LONGCALL6:
12341 removed = nds32_elf_relax_longcall6 (abfd, sec, irel, internal_relocs,
12342 &insn_len, contents, isymbuf,
12343 symtab_hdr);
12344 break;
12345 case R_NDS32_LONGJUMP4:
12346 removed = nds32_elf_relax_longjump4 (abfd, sec, irel, internal_relocs,
12347 &insn_len, contents, isymbuf,
12348 symtab_hdr);
12349 break;
12350 case R_NDS32_LONGJUMP5:
12351 removed = nds32_elf_relax_longjump5 (abfd, sec, irel, internal_relocs,
12352 &insn_len, &seq_len, contents,
12353 isymbuf, symtab_hdr);
12354 break;
12355 case R_NDS32_LONGJUMP6:
12356 removed = nds32_elf_relax_longjump6 (abfd, sec, irel, internal_relocs,
12357 &insn_len, &seq_len, contents,
12358 isymbuf, symtab_hdr);
12359 break;
12360 case R_NDS32_LONGJUMP7:
12361 removed = nds32_elf_relax_longjump7 (abfd, sec, irel, internal_relocs,
12362 &insn_len, &seq_len, contents,
12363 isymbuf, symtab_hdr);
12364 break;
12365 case R_NDS32_LOADSTORE:
12366 removed = nds32_elf_relax_loadstore (link_info, abfd, sec, irel,
12367 internal_relocs, &insn_len,
12368 contents, isymbuf, symtab_hdr,
12369 load_store_relax, table);
12370 break;
12371 case R_NDS32_LO12S0_RELA:
12372 case R_NDS32_LO12S1_RELA:
12373 case R_NDS32_LO12S2_RELA:
12374 case R_NDS32_LO12S2_DP_RELA:
12375 case R_NDS32_LO12S2_SP_RELA:
12376 /* Relax for low part. */
12377 nds32_elf_relax_lo12 (link_info, abfd, sec, irel, internal_relocs,
12378 contents, isymbuf, symtab_hdr, table);
12379
12380 /* It is impossible to delete blank, so just continue. */
12381 continue;
12382 case R_NDS32_PTR:
12383 removed = nds32_elf_relax_ptr (abfd, sec, irel, internal_relocs,
12384 &insn_len, &seq_len, contents);
12385 break;
12386 case R_NDS32_LSI:
12387 nds32_elf_relax_flsi (link_info, abfd, sec, irel, internal_relocs,
12388 contents, isymbuf, symtab_hdr, again);
12389 continue;
12390 case R_NDS32_GOT_LO12:
12391 case R_NDS32_GOTOFF_LO12:
12392 case R_NDS32_PLTREL_LO12:
12393 case R_NDS32_PLT_GOTREL_LO12:
12394 case R_NDS32_GOTPC_LO12:
12395 case R_NDS32_TLS_LE_LO12:
12396 case R_NDS32_TLS_LE_ADD:
12397 case R_NDS32_TLS_LE_LS:
12398 case R_NDS32_PLT_GOT_SUFF:
12399 case R_NDS32_GOT_SUFF:
12400 case R_NDS32_GOTOFF_SUFF:
12401 continue;
12402 default:
12403 continue;
12404 }
12405
12406 if (removed && seq_len - insn_len > 0)
12407 {
12408 if (!insert_nds32_elf_blank
12409 (&relax_blank_list, irel->r_offset + insn_len,
12410 seq_len - insn_len))
12411 goto error_return;
12412 *again = TRUE;
12413 }
12414 }
12415
12416 calc_nds32_blank_total (relax_blank_list);
12417
12418 if (table->relax_fp_as_gp)
12419 {
12420 if (!nds32_relax_fp_as_gp (link_info, abfd, sec, internal_relocs,
12421 irelend, isymbuf))
12422 goto error_return;
12423
12424 if (!*again)
12425 {
12426 if (!nds32_fag_remove_unused_fpbase (abfd, sec, internal_relocs,
12427 irelend))
12428 goto error_return;
12429 }
12430 }
12431
12432 if (!*again)
12433 {
12434 if (!nds32_relax_adjust_label (abfd, sec, internal_relocs, contents,
12435 &relax_blank_list, optimize, opt_size))
12436 goto error_return;
12437 }
12438
12439 /* It doesn't matter optimize_for_space_no_align anymore.
12440 If object file is assembled with flag '-Os',
12441 the we don't adjust jump-destination on 4-byte boundary. */
12442
12443 if (relax_blank_list)
12444 {
12445 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12446 relax_blank_list = NULL;
12447 }
12448
12449 if (!*again)
12450 {
12451 /* Closing the section, so we don't relax it anymore. */
12452 bfd_vma sec_size_align;
12453 Elf_Internal_Rela *tmp_rel;
12454
12455 /* Pad to alignment boundary. Only handle current section alignment. */
12456 sec_size_align = (sec->size + (~((-1U) << sec->alignment_power)))
12457 & ((-1U) << sec->alignment_power);
12458 if ((sec_size_align - sec->size) & 0x2)
12459 {
12460 insn16 = NDS32_NOP16;
12461 bfd_putb16 (insn16, contents + sec->size);
12462 sec->size += 2;
12463 }
12464
12465 while (sec_size_align != sec->size)
12466 {
12467 insn = NDS32_NOP32;
12468 bfd_putb32 (insn, contents + sec->size);
12469 sec->size += 4;
12470 }
12471
12472 tmp_rel = find_relocs_at_address (internal_relocs, internal_relocs,
12473 irelend, R_NDS32_RELAX_ENTRY);
12474 if (tmp_rel != irelend)
12475 tmp_rel->r_addend |= R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG;
12476
12477 clean_nds32_elf_blank ();
12478 }
12479
12480 finish:
12481 if (elf_section_data (sec)->relocs != internal_relocs)
12482 free (internal_relocs);
12483
12484 if (elf_section_data (sec)->this_hdr.contents != contents)
12485 free (contents);
12486
12487 if (symtab_hdr->contents != (bfd_byte *) isymbuf)
12488 free (isymbuf);
12489
12490 return result;
12491
12492 error_return:
12493 result = FALSE;
12494 goto finish;
12495 }
12496
12497 static struct bfd_elf_special_section const nds32_elf_special_sections[] =
12498 {
12499 {".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE},
12500 {".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE},
12501 {NULL, 0, 0, 0, 0}
12502 };
12503
12504 static bfd_boolean
12505 nds32_elf_section_flags (const Elf_Internal_Shdr *hdr)
12506 {
12507 const char *name = hdr->bfd_section->name;
12508
12509 if (strncmp (name, ".sbss", 5) == 0
12510 || strncmp (name, ".sdata", 6) == 0)
12511 hdr->bfd_section->flags |= SEC_SMALL_DATA;
12512
12513 return TRUE;
12514 }
12515
12516 static bfd_boolean
12517 nds32_elf_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
12518 struct bfd_link_info *info,
12519 void *finfo ATTRIBUTE_UNUSED,
12520 bfd_boolean (*func) (void *, const char *,
12521 Elf_Internal_Sym *,
12522 asection *,
12523 struct elf_link_hash_entry *)
12524 ATTRIBUTE_UNUSED)
12525 {
12526 FILE *sym_ld_script = NULL;
12527 struct elf_nds32_link_hash_table *table;
12528
12529 table = nds32_elf_hash_table (info);
12530 sym_ld_script = table->sym_ld_script;
12531
12532 if (check_start_export_sym)
12533 fprintf (sym_ld_script, "}\n");
12534
12535 return TRUE;
12536 }
12537
12538 static enum elf_reloc_type_class
12539 nds32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
12540 const asection *rel_sec ATTRIBUTE_UNUSED,
12541 const Elf_Internal_Rela *rela)
12542 {
12543 switch ((int) ELF32_R_TYPE (rela->r_info))
12544 {
12545 case R_NDS32_RELATIVE:
12546 return reloc_class_relative;
12547 case R_NDS32_JMP_SLOT:
12548 return reloc_class_plt;
12549 case R_NDS32_COPY:
12550 return reloc_class_copy;
12551 default:
12552 return reloc_class_normal;
12553 }
12554 }
12555
12556 /* Put target dependent option into info hash table. */
12557 void
12558 bfd_elf32_nds32_set_target_option (struct bfd_link_info *link_info,
12559 int relax_fp_as_gp,
12560 int eliminate_gc_relocs,
12561 FILE * sym_ld_script,
12562 int hyper_relax,
12563 int tls_desc_trampoline,
12564 int load_store_relax)
12565 {
12566 struct elf_nds32_link_hash_table *table;
12567
12568 table = nds32_elf_hash_table (link_info);
12569 if (table == NULL)
12570 return;
12571
12572 table->relax_fp_as_gp = relax_fp_as_gp;
12573 table->eliminate_gc_relocs = eliminate_gc_relocs;
12574 table->sym_ld_script = sym_ld_script;
12575 table->hyper_relax = hyper_relax;
12576 table->tls_desc_trampoline = tls_desc_trampoline;
12577 table ->load_store_relax = load_store_relax;
12578 }
12579 \f
12580
12581 /* These functions and data-structures are used for fp-as-gp
12582 optimization. */
12583
12584 #define FAG_THRESHOLD 3 /* At least 3 gp-access. */
12585 /* lwi37.fp covers 508 bytes, but there may be 32-byte padding between
12586 the read-only section and read-write section. */
12587 #define FAG_WINDOW (508 - 32)
12588
12589 /* An nds32_fag represent a gp-relative access.
12590 We find best fp-base by using a sliding window
12591 to find a base address which can cover most gp-access. */
12592 struct nds32_fag
12593 {
12594 struct nds32_fag *next; /* NULL-teminated linked list. */
12595 bfd_vma addr; /* The address of this fag. */
12596 Elf_Internal_Rela **relas; /* The relocations associated with this fag.
12597 It is used for applying FP7U2_FLAG. */
12598 int count; /* How many times this address is referred.
12599 There should be exactly `count' relocations
12600 in relas. */
12601 int relas_capcity; /* The buffer size of relas.
12602 We use an array instead of linked-list,
12603 and realloc is used to adjust buffer size. */
12604 };
12605
12606 static void
12607 nds32_fag_init (struct nds32_fag *head)
12608 {
12609 memset (head, 0, sizeof (struct nds32_fag));
12610 }
12611
12612 static void
12613 nds32_fag_verify (struct nds32_fag *head)
12614 {
12615 struct nds32_fag *iter;
12616 struct nds32_fag *prev;
12617
12618 prev = NULL;
12619 iter = head->next;
12620 while (iter)
12621 {
12622 if (prev && prev->addr >= iter->addr)
12623 puts ("Bug in fp-as-gp insertion.");
12624 prev = iter;
12625 iter = iter->next;
12626 }
12627 }
12628
12629 /* Insert a fag in ascending order.
12630 If a fag of the same address already exists,
12631 they are chained by relas array. */
12632
12633 static void
12634 nds32_fag_insert (struct nds32_fag *head, bfd_vma addr,
12635 Elf_Internal_Rela * rel)
12636 {
12637 struct nds32_fag *iter;
12638 struct nds32_fag *new_fag;
12639 const int INIT_RELAS_CAP = 4;
12640
12641 for (iter = head;
12642 iter->next && iter->next->addr <= addr;
12643 iter = iter->next)
12644 /* Find somewhere to insert. */ ;
12645
12646 /* `iter' will be equal to `head' if the list is empty. */
12647 if (iter != head && iter->addr == addr)
12648 {
12649 /* The address exists in the list.
12650 Insert `rel' into relocation list, relas. */
12651
12652 /* Check whether relas is big enough. */
12653 if (iter->count >= iter->relas_capcity)
12654 {
12655 iter->relas_capcity *= 2;
12656 iter->relas = bfd_realloc
12657 (iter->relas, iter->relas_capcity * sizeof (void *));
12658 }
12659 iter->relas[iter->count++] = rel;
12660 return;
12661 }
12662
12663 /* This is a new address. Create a fag node for it. */
12664 new_fag = bfd_malloc (sizeof (struct nds32_fag));
12665 memset (new_fag, 0, sizeof (*new_fag));
12666 new_fag->addr = addr;
12667 new_fag->count = 1;
12668 new_fag->next = iter->next;
12669 new_fag->relas_capcity = INIT_RELAS_CAP;
12670 new_fag->relas = (Elf_Internal_Rela **)
12671 bfd_malloc (new_fag->relas_capcity * sizeof (void *));
12672 new_fag->relas[0] = rel;
12673 iter->next = new_fag;
12674
12675 nds32_fag_verify (head);
12676 }
12677
12678 static void
12679 nds32_fag_free_list (struct nds32_fag *head)
12680 {
12681 struct nds32_fag *iter;
12682
12683 iter = head->next;
12684 while (iter)
12685 {
12686 struct nds32_fag *tmp = iter;
12687 iter = iter->next;
12688 free (tmp->relas);
12689 tmp->relas = NULL;
12690 free (tmp);
12691 }
12692 }
12693
12694 /* Find the best fp-base address.
12695 The relocation associated with that address is returned,
12696 so we can track the symbol instead of a fixed address.
12697
12698 When relaxation, the address of an datum may change,
12699 because a text section is shrinked, so the data section
12700 moves forward. If the aligments of text and data section
12701 are different, their distance may change too.
12702 Therefore, tracking a fixed address is not appriate. */
12703
12704 static int
12705 nds32_fag_find_base (struct nds32_fag *head, struct nds32_fag **bestpp)
12706 {
12707 struct nds32_fag *base; /* First fag in the window. */
12708 struct nds32_fag *last; /* First fag outside the window. */
12709 int accu = 0; /* Usage accumulation. */
12710 struct nds32_fag *best; /* Best fag. */
12711 int baccu = 0; /* Best accumulation. */
12712
12713 /* Use first fag for initial, and find the last fag in the window.
12714
12715 In each iteration, we could simply subtract previous fag
12716 and accumulate following fags which are inside the window,
12717 untill we each the end. */
12718
12719 if (head->next == NULL)
12720 {
12721 *bestpp = NULL;
12722 return 0;
12723 }
12724
12725 /* Initialize base. */
12726 base = head->next;
12727 best = base;
12728 for (last = base;
12729 last && last->addr < base->addr + FAG_WINDOW;
12730 last = last->next)
12731 accu += last->count;
12732
12733 baccu = accu;
12734
12735 /* Record the best base in each iteration. */
12736 while (base->next)
12737 {
12738 accu -= base->count;
12739 base = base->next;
12740 /* Account fags in window. */
12741 for (/* Nothing. */;
12742 last && last->addr < base->addr + FAG_WINDOW;
12743 last = last->next)
12744 accu += last->count;
12745
12746 /* A better fp-base? */
12747 if (accu > baccu)
12748 {
12749 best = base;
12750 baccu = accu;
12751 }
12752 }
12753
12754 if (bestpp)
12755 *bestpp = best;
12756 return baccu;
12757 }
12758
12759 /* Apply R_NDS32_INSN16_FP7U2_FLAG on gp-relative accesses,
12760 so we can convert it fo fp-relative access later.
12761 `best_fag' is the best fp-base. Only those inside the window
12762 of best_fag is applied the flag. */
12763
12764 static bfd_boolean
12765 nds32_fag_mark_relax (struct bfd_link_info *link_info,
12766 asection *sec, struct nds32_fag *best_fag,
12767 Elf_Internal_Rela *internal_relocs,
12768 Elf_Internal_Rela *irelend)
12769 {
12770 struct nds32_fag *ifag;
12771 bfd_vma best_fpbase, gp;
12772 bfd *output_bfd;
12773
12774 output_bfd = sec->output_section->owner;
12775 nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
12776 best_fpbase = best_fag->addr;
12777
12778 if (best_fpbase > gp + sdata_range[1][1]
12779 || best_fpbase < gp - sdata_range[1][0])
12780 return FALSE;
12781
12782 /* Mark these inside the window R_NDS32_INSN16_FP7U2_FLAG flag,
12783 so we know they can be converted to lwi37.fp. */
12784 for (ifag = best_fag;
12785 ifag && ifag->addr < best_fpbase + FAG_WINDOW; ifag = ifag->next)
12786 {
12787 int i;
12788
12789 for (i = 0; i < ifag->count; i++)
12790 {
12791 Elf_Internal_Rela *insn16_rel;
12792 Elf_Internal_Rela *fag_rel;
12793
12794 fag_rel = ifag->relas[i];
12795
12796 /* Only if this is within the WINDOWS, FP7U2_FLAG
12797 is applied. */
12798
12799 insn16_rel = find_relocs_at_address
12800 (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12801
12802 if (insn16_rel != irelend)
12803 insn16_rel->r_addend = R_NDS32_INSN16_FP7U2_FLAG;
12804 }
12805 }
12806 return TRUE;
12807 }
12808
12809 /* Reset INSN16 to clean fp as gp. */
12810
12811 static void
12812 nds32_fag_unmark_relax (struct nds32_fag *fag,
12813 Elf_Internal_Rela *internal_relocs,
12814 Elf_Internal_Rela *irelend)
12815 {
12816 struct nds32_fag *ifag;
12817 int i;
12818 Elf_Internal_Rela *insn16_rel;
12819 Elf_Internal_Rela *fag_rel;
12820
12821 for (ifag = fag; ifag; ifag = ifag->next)
12822 {
12823 for (i = 0; i < ifag->count; i++)
12824 {
12825 fag_rel = ifag->relas[i];
12826
12827 /* Restore the INSN16 relocation. */
12828 insn16_rel = find_relocs_at_address
12829 (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12830
12831 if (insn16_rel != irelend)
12832 insn16_rel->r_addend &= ~R_NDS32_INSN16_FP7U2_FLAG;
12833 }
12834 }
12835 }
12836
12837 /* This is the main function of fp-as-gp optimization.
12838 It should be called by relax_section. */
12839
12840 static bfd_boolean
12841 nds32_relax_fp_as_gp (struct bfd_link_info *link_info,
12842 bfd *abfd, asection *sec,
12843 Elf_Internal_Rela *internal_relocs,
12844 Elf_Internal_Rela *irelend,
12845 Elf_Internal_Sym *isymbuf)
12846 {
12847 Elf_Internal_Rela *begin_rel = NULL;
12848 Elf_Internal_Rela *irel;
12849 struct nds32_fag fag_head;
12850 Elf_Internal_Shdr *symtab_hdr;
12851 bfd_byte *contents;
12852 bfd_boolean ifc_inside = FALSE;
12853
12854 /* FIXME: Can we bfd_elf_link_read_relocs for the relocs? */
12855
12856 /* Per-function fp-base selection.
12857 1. Create a list for all the gp-relative access.
12858 2. Base on those gp-relative address,
12859 find a fp-base which can cover most access.
12860 3. Use the fp-base for fp-as-gp relaxation.
12861
12862 NOTE: If fp-as-gp is not worth to do, (e.g., less than 3 times),
12863 we should
12864 1. delete the `la $fp, _FP_BASE_' instruction and
12865 2. not convert lwi.gp to lwi37.fp.
12866
12867 To delete the _FP_BASE_ instruction, we simply apply
12868 R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG flag in the r_addend to disable it.
12869
12870 To suppress the conversion, we simply NOT to apply
12871 R_NDS32_INSN16_FP7U2_FLAG flag. */
12872
12873 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12874
12875 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12876 || !nds32_get_local_syms (abfd, sec, &isymbuf))
12877 return FALSE;
12878
12879 /* Check whether it is worth for fp-as-gp optimization,
12880 i.e., at least 3 gp-load.
12881
12882 Set R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG if we should NOT
12883 apply this optimization. */
12884
12885 for (irel = internal_relocs; irel < irelend; irel++)
12886 {
12887 /* We recognize R_NDS32_RELAX_REGION_BEGIN/_END for the region.
12888 One we enter the begin of the region, we track all the LW/ST
12889 instructions, so when we leave the region, we try to find
12890 the best fp-base address for those LW/ST instructions. */
12891
12892 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12893 && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12894 {
12895 /* Begin of the region. */
12896 if (begin_rel)
12897 /* xgettext:c-format */
12898 _bfd_error_handler (_("%pB: nested OMIT_FP in %pA"), abfd, sec);
12899
12900 begin_rel = irel;
12901 nds32_fag_init (&fag_head);
12902 ifc_inside = FALSE;
12903 }
12904 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
12905 && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12906 {
12907 int accu;
12908 struct nds32_fag *best_fag, *tmp_fag;
12909 int dist;
12910
12911 /* End of the region.
12912 Check whether it is worth to do fp-as-gp. */
12913
12914 if (begin_rel == NULL)
12915 {
12916 /* xgettext:c-format */
12917 _bfd_error_handler (_("%pB: unmatched OMIT_FP in %pA"),
12918 abfd, sec);
12919 continue;
12920 }
12921
12922 accu = nds32_fag_find_base (&fag_head, &best_fag);
12923
12924 /* Clean FP7U2_FLAG because they may set ever. */
12925 tmp_fag = fag_head.next;
12926 nds32_fag_unmark_relax (tmp_fag, internal_relocs, irelend);
12927
12928 /* Check if it is worth, and FP_BASE is near enough to SDA_BASE. */
12929 if (accu < FAG_THRESHOLD
12930 || !nds32_fag_mark_relax (link_info, sec, best_fag,
12931 internal_relocs, irelend))
12932 {
12933 /* Not worth to do fp-as-gp. */
12934 begin_rel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
12935 begin_rel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
12936 irel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
12937 irel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
12938 nds32_fag_free_list (&fag_head);
12939 begin_rel = NULL;
12940 continue;
12941 }
12942
12943 /* R_SYM of R_NDS32_RELAX_REGION_BEGIN is not used by assembler,
12944 so we use it to record the distance to the reloction of best
12945 fp-base. */
12946 dist = best_fag->relas[0] - begin_rel;
12947 BFD_ASSERT (dist > 0 && dist < 0xffffff);
12948 /* Use high 16 bits of addend to record the _FP_BASE_ matched
12949 relocation. And get the base value when relocating. */
12950 begin_rel->r_addend &= (0x1 << 16) - 1;
12951 begin_rel->r_addend |= dist << 16;
12952
12953 nds32_fag_free_list (&fag_head);
12954 begin_rel = NULL;
12955 }
12956
12957 if (begin_rel == NULL || ifc_inside)
12958 /* Skip if we are not in the region of fp-as-gp. */
12959 continue;
12960
12961 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S2_RELA
12962 || ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA17S2_RELA)
12963 {
12964 bfd_vma addr;
12965 uint32_t insn;
12966
12967 /* A gp-relative access is found. Insert it to the fag-list. */
12968
12969 /* Rt is necessary an RT3, so it can be converted to lwi37.fp. */
12970 insn = bfd_getb32 (contents + irel->r_offset);
12971 if (!N32_IS_RT3 (insn))
12972 continue;
12973
12974 addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
12975 nds32_fag_insert (&fag_head, addr, irel);
12976 }
12977 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA_FP7U2_RELA)
12978 {
12979 begin_rel = NULL;
12980 }
12981 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12982 || ELF32_R_TYPE (irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
12983 {
12984 /* Suppress fp as gp when encounter ifc. */
12985 ifc_inside = TRUE;
12986 }
12987 }
12988
12989 return TRUE;
12990 }
12991
12992 /* Remove unused `la $fp, _FD_BASE_' instruction. */
12993
12994 static bfd_boolean
12995 nds32_fag_remove_unused_fpbase (bfd *abfd, asection *sec,
12996 Elf_Internal_Rela *internal_relocs,
12997 Elf_Internal_Rela *irelend)
12998 {
12999 Elf_Internal_Rela *irel;
13000 Elf_Internal_Shdr *symtab_hdr;
13001 bfd_byte *contents = NULL;
13002 nds32_elf_blank_t *relax_blank_list = NULL;
13003 bfd_boolean result = TRUE;
13004 bfd_boolean unused_region = FALSE;
13005
13006 /*
13007 NOTE: Disable fp-as-gp if we encounter ifcall relocations:
13008 R_NDS32_17IFC_PCREL_RELA
13009 R_NDS32_10IFCU_PCREL_RELA. */
13010
13011 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13012 nds32_get_section_contents (abfd, sec, &contents, TRUE);
13013
13014 for (irel = internal_relocs; irel < irelend; irel++)
13015 {
13016 /* To remove unused fp-base, we simply find the REGION_NOT_OMIT_FP
13017 we marked to in previous pass.
13018 DO NOT scan relocations again, since we've alreadly decided it
13019 and set the flag. */
13020 const char *syname;
13021 int syndx;
13022 uint32_t insn;
13023
13024 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
13025 && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
13026 unused_region = TRUE;
13027 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
13028 && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
13029 unused_region = FALSE;
13030
13031 /* We're not in the region. */
13032 if (!unused_region)
13033 continue;
13034
13035 /* _FP_BASE_ must be a GLOBAL symbol. */
13036 syndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
13037 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
13038 continue;
13039
13040 /* The symbol name must be _FP_BASE_. */
13041 syname = elf_sym_hashes (abfd)[syndx]->root.root.string;
13042 if (strcmp (syname, FP_BASE_NAME) != 0)
13043 continue;
13044
13045 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA19S0_RELA)
13046 {
13047 /* addi.gp $fp, -256 */
13048 insn = bfd_getb32 (contents + irel->r_offset);
13049 if (insn != INSN_ADDIGP_TO_FP)
13050 continue;
13051 }
13052 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S0_RELA)
13053 {
13054 /* addi $fp, $gp, -256 */
13055 insn = bfd_getb32 (contents + irel->r_offset);
13056 if (insn != INSN_ADDI_GP_TO_FP)
13057 continue;
13058 }
13059 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_20_RELA)
13060 {
13061 /* movi $fp, FP_BASE */
13062 insn = bfd_getb32 (contents + irel->r_offset);
13063 if (insn != INSN_MOVI_TO_FP)
13064 continue;
13065 }
13066 else
13067 continue;
13068
13069 /* We got here because a FP_BASE instruction is found. */
13070 if (!insert_nds32_elf_blank_recalc_total
13071 (&relax_blank_list, irel->r_offset, 4))
13072 goto error_return;
13073 }
13074
13075 finish:
13076 if (relax_blank_list)
13077 {
13078 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
13079 relax_blank_list = NULL;
13080 }
13081 return result;
13082
13083 error_return:
13084 result = FALSE;
13085 goto finish;
13086 }
13087
13088 /* This is a version of bfd_generic_get_relocated_section_contents.
13089 We need this variety because relaxation will modify the dwarf
13090 infomation. When there is undefined symbol reference error mesage,
13091 linker need to dump line number where the symbol be used. However
13092 the address is be relaxed, it can not get the original dwarf contents.
13093 The variety only modify function call for reading in the section. */
13094
13095 static bfd_byte *
13096 nds32_elf_get_relocated_section_contents (bfd *abfd,
13097 struct bfd_link_info *link_info,
13098 struct bfd_link_order *link_order,
13099 bfd_byte *data,
13100 bfd_boolean relocatable,
13101 asymbol **symbols)
13102 {
13103 bfd *input_bfd = link_order->u.indirect.section->owner;
13104 asection *input_section = link_order->u.indirect.section;
13105 long reloc_size;
13106 arelent **reloc_vector;
13107 long reloc_count;
13108
13109 reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
13110 if (reloc_size < 0)
13111 return NULL;
13112
13113 /* Read in the section. */
13114 if (!nds32_get_section_contents (input_bfd, input_section, &data, FALSE))
13115 return NULL;
13116
13117 if (reloc_size == 0)
13118 return data;
13119
13120 reloc_vector = (arelent **) bfd_malloc (reloc_size);
13121 if (reloc_vector == NULL)
13122 return NULL;
13123
13124 reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
13125 reloc_vector, symbols);
13126 if (reloc_count < 0)
13127 goto error_return;
13128
13129 if (reloc_count > 0)
13130 {
13131 arelent **parent;
13132 for (parent = reloc_vector; *parent != NULL; parent++)
13133 {
13134 char *error_message = NULL;
13135 asymbol *symbol;
13136 bfd_reloc_status_type r;
13137
13138 symbol = *(*parent)->sym_ptr_ptr;
13139 if (symbol->section && discarded_section (symbol->section))
13140 {
13141 bfd_vma off;
13142 static reloc_howto_type none_howto
13143 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL,
13144 "unused", FALSE, 0, 0, FALSE);
13145
13146 off = (*parent)->address * OCTETS_PER_BYTE (input_bfd,
13147 input_section);
13148 _bfd_clear_contents ((*parent)->howto, input_bfd,
13149 input_section, data, off);
13150 (*parent)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
13151 (*parent)->addend = 0;
13152 (*parent)->howto = &none_howto;
13153 r = bfd_reloc_ok;
13154 }
13155 else
13156 r = bfd_perform_relocation (input_bfd, *parent, data,
13157 input_section,
13158 relocatable ? abfd : NULL,
13159 &error_message);
13160
13161 if (relocatable)
13162 {
13163 asection *os = input_section->output_section;
13164
13165 /* A partial link, so keep the relocs. */
13166 os->orelocation[os->reloc_count] = *parent;
13167 os->reloc_count++;
13168 }
13169
13170 if (r != bfd_reloc_ok)
13171 {
13172 switch (r)
13173 {
13174 case bfd_reloc_undefined:
13175 (*link_info->callbacks->undefined_symbol)
13176 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13177 input_bfd, input_section, (*parent)->address, TRUE);
13178 break;
13179 case bfd_reloc_dangerous:
13180 BFD_ASSERT (error_message != NULL);
13181 (*link_info->callbacks->reloc_dangerous)
13182 (link_info, error_message,
13183 input_bfd, input_section, (*parent)->address);
13184 break;
13185 case bfd_reloc_overflow:
13186 (*link_info->callbacks->reloc_overflow)
13187 (link_info, NULL,
13188 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13189 (*parent)->howto->name, (*parent)->addend,
13190 input_bfd, input_section, (*parent)->address);
13191 break;
13192 case bfd_reloc_outofrange:
13193 /* PR ld/13730:
13194 This error can result when processing some partially
13195 complete binaries. Do not abort, but issue an error
13196 message instead. */
13197 link_info->callbacks->einfo
13198 /* xgettext:c-format */
13199 (_("%X%P: %pB(%pA): relocation \"%pR\" goes out of range\n"),
13200 abfd, input_section, * parent);
13201 goto error_return;
13202
13203 default:
13204 abort ();
13205 break;
13206 }
13207 }
13208 }
13209 }
13210
13211 free (reloc_vector);
13212 return data;
13213
13214 error_return:
13215 free (reloc_vector);
13216 return NULL;
13217 }
13218
13219 /* Check target symbol. */
13220
13221 static bfd_boolean
13222 nds32_elf_is_target_special_symbol (bfd *abfd ATTRIBUTE_UNUSED, asymbol *sym)
13223 {
13224 if (!sym || !sym->name || sym->name[0] != '$')
13225 return FALSE;
13226 return TRUE;
13227 }
13228
13229 /* nds32 find maybe function sym. Ignore target special symbol
13230 first, and then go the general function. */
13231
13232 static bfd_size_type
13233 nds32_elf_maybe_function_sym (const asymbol *sym, asection *sec,
13234 bfd_vma *code_off)
13235 {
13236 if (nds32_elf_is_target_special_symbol (NULL, (asymbol *) sym))
13237 return 0;
13238
13239 return _bfd_elf_maybe_function_sym (sym, sec, code_off);
13240 }
13241 \f
13242
13243 /* Do TLS model conversion. */
13244
13245 typedef struct relax_group_list_t
13246 {
13247 Elf_Internal_Rela *relo;
13248 struct relax_group_list_t *next;
13249 struct relax_group_list_t *next_sibling;
13250 int id;
13251 } relax_group_list_t;
13252
13253 int
13254 list_insert (relax_group_list_t *pHead, Elf_Internal_Rela *pElem);
13255
13256 int
13257 list_insert_sibling (relax_group_list_t *pNode, Elf_Internal_Rela *pElem);
13258
13259 void
13260 dump_chain (relax_group_list_t *pHead);
13261
13262 int
13263 list_insert (relax_group_list_t *pHead, Elf_Internal_Rela *pElem)
13264 {
13265 relax_group_list_t *pNext = pHead;
13266
13267 /* Find place. */
13268 while (pNext->next)
13269 {
13270 if (pNext->next->id > (int) pElem->r_addend)
13271 break;
13272
13273 pNext = pNext->next;
13274 }
13275
13276 /* Insert node. */
13277 relax_group_list_t *pNew = bfd_malloc (sizeof (relax_group_list_t));
13278 if (!pNew)
13279 return FALSE;
13280
13281 relax_group_list_t *tmp = pNext->next;
13282 pNext->next = pNew;
13283
13284 pNew->id = pElem->r_addend;
13285 pNew->relo = pElem;
13286 pNew->next = tmp;
13287 pNew->next_sibling = NULL;
13288
13289 return TRUE;
13290 }
13291
13292 int
13293 list_insert_sibling (relax_group_list_t *pNode, Elf_Internal_Rela *pElem)
13294 {
13295 relax_group_list_t *pNext = pNode;
13296
13297 /* Find place. */
13298 while (pNext->next_sibling)
13299 {
13300 pNext = pNext->next_sibling;
13301 }
13302
13303 /* Insert node. */
13304 relax_group_list_t *pNew = bfd_malloc (sizeof (relax_group_list_t));
13305 if (!pNew)
13306 return FALSE;
13307
13308 relax_group_list_t *tmp = pNext->next_sibling;
13309 pNext->next_sibling = pNew;
13310
13311 pNew->id = -1;
13312 pNew->relo = pElem;
13313 pNew->next = NULL;
13314 pNew->next_sibling = tmp;
13315
13316 return TRUE;
13317 }
13318
13319 void
13320 dump_chain (relax_group_list_t *pHead)
13321 {
13322 relax_group_list_t *pNext = pHead->next;
13323 while (pNext)
13324 {
13325 printf("group %d @ 0x%08x", pNext->id, (unsigned)pNext->relo->r_offset);
13326 relax_group_list_t *pNextSib = pNext->next_sibling;
13327 while (pNextSib)
13328 {
13329 printf(", %d", (unsigned) ELF32_R_TYPE (pNextSib->relo->r_info));
13330 pNextSib = pNextSib->next_sibling;
13331 }
13332 pNext = pNext->next;
13333 printf("\n");
13334 }
13335 }
13336
13337 /* Check R_NDS32_RELAX_GROUP of each section.
13338 There might be multiple sections in one object file. */
13339
13340 int
13341 elf32_nds32_check_relax_group (bfd *abfd, asection *asec)
13342 {
13343 elf32_nds32_relax_group_t *relax_group_ptr =
13344 elf32_nds32_relax_group_ptr (abfd);
13345
13346 int min_id = relax_group_ptr->min_id;
13347 int max_id = relax_group_ptr->max_id;
13348
13349 Elf_Internal_Rela *rel;
13350 Elf_Internal_Rela *relend;
13351 Elf_Internal_Rela *relocs;
13352 enum elf_nds32_reloc_type rtype;
13353
13354 do
13355 {
13356 /* Relocations MUST be kept in memory, because relaxation adjust them. */
13357 relocs = _bfd_elf_link_read_relocs (abfd, asec, NULL, NULL,
13358 TRUE /* keep_memory */);
13359 if (relocs == NULL)
13360 break;
13361
13362 /* Check R_NDS32_RELAX_GROUP. */
13363 relend = relocs + asec->reloc_count;
13364 for (rel = relocs; rel < relend; rel++)
13365 {
13366 int id;
13367 rtype = ELF32_R_TYPE (rel->r_info);
13368 if (rtype != R_NDS32_RELAX_GROUP)
13369 continue;
13370
13371 id = rel->r_addend;
13372 if (id < min_id)
13373 min_id = id;
13374 else if (id > max_id)
13375 max_id = id;
13376 }
13377 }
13378 while (FALSE);
13379
13380 if (elf_section_data (asec)->relocs != relocs)
13381 free (relocs);
13382
13383 if ((min_id != relax_group_ptr->min_id)
13384 || (max_id != relax_group_ptr->max_id))
13385 {
13386 relax_group_ptr->count = max_id - min_id + 1;
13387 BFD_ASSERT(min_id <= relax_group_ptr->min_id);
13388 relax_group_ptr->min_id = min_id;
13389 BFD_ASSERT(max_id >= relax_group_ptr->max_id);
13390 relax_group_ptr->max_id = max_id;
13391 }
13392
13393 return relax_group_ptr->count;
13394 }
13395
13396 /* Reorder RELAX_GROUP ID when command line option '-r' is applied. */
13397 struct section_id_list_t *relax_group_section_id_list = NULL;
13398
13399 struct section_id_list_t *
13400 elf32_nds32_lookup_section_id (int id, struct section_id_list_t **lst_ptr)
13401 {
13402 struct section_id_list_t *result = NULL;
13403 struct section_id_list_t *lst = *lst_ptr;
13404
13405 if (NULL == lst)
13406 {
13407 result = (struct section_id_list_t *) calloc
13408 (1, sizeof (struct section_id_list_t));
13409 BFD_ASSERT (result); /* Feed me. */
13410 result->id = id;
13411 *lst_ptr = result;
13412 }
13413 else
13414 {
13415 struct section_id_list_t *cur = lst;
13416 struct section_id_list_t *prv = NULL;
13417 struct section_id_list_t *sec = NULL;
13418
13419 while (cur)
13420 {
13421 if (cur->id < id)
13422 {
13423 prv = cur;
13424 cur = cur->next;
13425 continue;
13426 }
13427
13428 if (cur->id > id)
13429 {
13430 cur = NULL; /* To insert after prv. */
13431 sec = cur; /* In case prv == NULL. */
13432 }
13433
13434 break;
13435 }
13436
13437 if (NULL == cur)
13438 {
13439 /* Insert after prv. */
13440 result = (struct section_id_list_t *) calloc
13441 (1, sizeof (struct section_id_list_t));
13442 BFD_ASSERT (result); /* Feed me. */
13443 result->id = id;
13444 if (NULL != prv)
13445 {
13446 result->next = prv->next;
13447 prv->next = result;
13448 }
13449 else
13450 {
13451 *lst_ptr = result;
13452 result->next = sec;
13453 }
13454 }
13455 }
13456
13457 return result;
13458 }
13459
13460 int
13461 elf32_nds32_unify_relax_group (bfd *abfd, asection *asec)
13462 {
13463 static int next_relax_group_bias = 0;
13464
13465 elf32_nds32_relax_group_t *relax_group_ptr =
13466 elf32_nds32_relax_group_ptr (abfd);
13467
13468 bfd_boolean result = TRUE;
13469 Elf_Internal_Rela *rel;
13470 Elf_Internal_Rela *relend;
13471 Elf_Internal_Rela *relocs = NULL;
13472 enum elf_nds32_reloc_type rtype;
13473 struct section_id_list_t *node = NULL;
13474 int count = 0;
13475
13476 do
13477 {
13478 if (0 == relax_group_ptr->count)
13479 break;
13480
13481 /* Check if this section has been handled. */
13482 node = elf32_nds32_lookup_section_id (asec->id, &relax_group_section_id_list);
13483 if (NULL == node)
13484 break; /* Hit, the section id has handled. */
13485
13486 /* Relocations MUST be kept in memory, because relaxation adjust them. */
13487 relocs = _bfd_elf_link_read_relocs (abfd, asec, NULL, NULL,
13488 TRUE /* keep_memory */);
13489 if (relocs == NULL)
13490 {
13491 BFD_ASSERT (0); /* feed me */
13492 break;
13493 }
13494
13495 /* Allocate group id bias for this bfd! */
13496 if (0 == relax_group_ptr->init)
13497 {
13498 relax_group_ptr->bias = next_relax_group_bias;
13499 next_relax_group_bias += relax_group_ptr->count;
13500 relax_group_ptr->init = 1;
13501 }
13502
13503 /* Reorder relax group groups. */
13504 relend = relocs + asec->reloc_count;
13505 for (rel = relocs; rel < relend; rel++)
13506 {
13507 rtype = ELF32_R_TYPE(rel->r_info);
13508 if (rtype != R_NDS32_RELAX_GROUP)
13509 continue;
13510
13511 /* Change it. */
13512 rel->r_addend += relax_group_ptr->bias;
13513 /* Debugging count. */
13514 count++;
13515 }
13516 }
13517 while (FALSE);
13518
13519 if (elf_section_data (asec)->relocs != relocs)
13520 free (relocs);
13521
13522 return result;
13523 }
13524
13525 int
13526 nds32_elf_unify_tls_model (bfd *inbfd, asection *insec, bfd_byte *incontents,
13527 struct bfd_link_info *lnkinfo)
13528 {
13529 bfd_boolean result = TRUE;
13530 Elf_Internal_Rela *irel;
13531 Elf_Internal_Rela *irelend;
13532 Elf_Internal_Rela *internal_relocs;
13533 unsigned long r_symndx;
13534 enum elf_nds32_reloc_type r_type;
13535
13536 Elf_Internal_Sym *local_syms = NULL;
13537 bfd_byte *contents = NULL;
13538
13539 relax_group_list_t chain = { .id = -1, .next = NULL, .next_sibling = NULL };
13540
13541 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (inbfd)->symtab_hdr;
13542 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
13543 sym_hashes = elf_sym_hashes (inbfd);
13544 sym_hashes_end =
13545 sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
13546 if (!elf_bad_symtab (inbfd))
13547 sym_hashes_end -= symtab_hdr->sh_info;
13548
13549 /* Reorder RELAX_GROUP when command line option '-r' is applied. */
13550 if (bfd_link_relocatable (lnkinfo))
13551 {
13552 elf32_nds32_unify_relax_group (inbfd, insec);
13553 return result;
13554 }
13555
13556 /* Relocations MUST be kept in memory, because relaxation adjust them. */
13557 internal_relocs = _bfd_elf_link_read_relocs (inbfd, insec, NULL, NULL,
13558 TRUE /* keep_memory */);
13559 if (internal_relocs == NULL)
13560 goto error_return;
13561
13562 irelend = internal_relocs + insec->reloc_count;
13563 irel = find_relocs_at_address (internal_relocs, internal_relocs,
13564 irelend, R_NDS32_RELAX_ENTRY);
13565 if (irel == irelend)
13566 goto finish;
13567
13568 /* Chain/remove groups. */
13569 for (irel = internal_relocs; irel < irelend; irel++)
13570 {
13571 r_symndx = ELF32_R_SYM (irel->r_info);
13572 r_type = ELF32_R_TYPE (irel->r_info);
13573 if (r_type != R_NDS32_RELAX_GROUP)
13574 continue;
13575
13576 /* Remove it. */
13577 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_NONE);
13578 /* Chain it now. */
13579 if (!list_insert (&chain, irel))
13580 goto error_return;
13581 }
13582
13583 /* Collect group relocations. */
13584 /* Presume relocations are sorted. */
13585 relax_group_list_t *pNext = chain.next;
13586 while (pNext)
13587 {
13588 for (irel = internal_relocs; irel < irelend; irel++)
13589 {
13590 if (irel->r_offset == pNext->relo->r_offset)
13591 {
13592 /* Ignore Non-TLS relocation types. */
13593 r_type = ELF32_R_TYPE (irel->r_info);
13594 if ((R_NDS32_TLS_LE_HI20 > r_type)
13595 || (R_NDS32_RELAX_ENTRY == r_type))
13596 continue;
13597
13598 if (!list_insert_sibling (pNext, irel))
13599 goto error_return;
13600 }
13601 else if (irel->r_offset > pNext->relo->r_offset)
13602 {
13603 pNext = pNext->next;
13604 if (!pNext)
13605 break;
13606
13607 bfd_vma current_offset = pNext->relo->r_offset;
13608 if (irel->r_offset > current_offset)
13609 irel = internal_relocs; /* restart from head */
13610 else
13611 --irel; /* Check current irel again. */
13612 continue;
13613 }
13614 else
13615 {
13616 /* This shouldn't be reached. */
13617 }
13618 }
13619 if (pNext)
13620 pNext = pNext->next;
13621 }
13622
13623 #ifdef DUBUG_VERBOSE
13624 dump_chain(&chain);
13625 #endif
13626
13627 /* Get symbol table and section content. */
13628 if (incontents)
13629 contents = incontents;
13630 else if (!nds32_get_section_contents (inbfd, insec, &contents, TRUE)
13631 || !nds32_get_local_syms (inbfd, insec, &local_syms))
13632 goto error_return;
13633
13634 char *local_got_tls_type = elf32_nds32_local_got_tls_type (inbfd);
13635
13636 /* Convert TLS model each group if necessary. */
13637 pNext = chain.next;
13638
13639 int cur_grp_id = -1;
13640 int sethi_rt = -1;
13641 int add_rt = -1;
13642 enum elf_nds32_tls_type tls_type, org_tls_type, eff_tls_type;
13643
13644 tls_type = org_tls_type = eff_tls_type = 0;
13645
13646 while (pNext)
13647 {
13648 relax_group_list_t *pNextSig = pNext->next_sibling;
13649 while (pNextSig)
13650 {
13651 struct elf_link_hash_entry *h = NULL;
13652
13653 irel = pNextSig->relo;
13654 r_symndx = ELF32_R_SYM(irel->r_info);
13655 r_type = ELF32_R_TYPE(irel->r_info);
13656
13657 if (pNext->id != cur_grp_id)
13658 {
13659 cur_grp_id = pNext->id;
13660 org_tls_type = get_tls_type (r_type, NULL);
13661 if (r_symndx >= symtab_hdr->sh_info)
13662 {
13663 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
13664 while (h->root.type == bfd_link_hash_indirect
13665 || h->root.type == bfd_link_hash_warning)
13666 h = (struct elf_link_hash_entry *) h->root.u.i.link;
13667 tls_type = ((struct elf_nds32_link_hash_entry *) h)->tls_type;
13668 }
13669 else
13670 {
13671 tls_type = local_got_tls_type
13672 ? local_got_tls_type[r_symndx]
13673 : GOT_NORMAL;
13674 }
13675
13676 eff_tls_type = 1 << (fls (tls_type) - 1);
13677 sethi_rt = N32_RT5(bfd_getb32 (contents + irel->r_offset));
13678 }
13679
13680 if (eff_tls_type != org_tls_type)
13681 {
13682 switch (org_tls_type)
13683 {
13684 /* DESC to IEGP/IE/LE. */
13685 case GOT_TLS_DESC:
13686 switch (eff_tls_type)
13687 {
13688 case GOT_TLS_IE:
13689 switch (r_type)
13690 {
13691 case R_NDS32_TLS_DESC_HI20:
13692 irel->r_info = ELF32_R_INFO(r_symndx,
13693 R_NDS32_TLS_IE_HI20);
13694 break;
13695 case R_NDS32_TLS_DESC_LO12:
13696 irel->r_info = ELF32_R_INFO(r_symndx,
13697 R_NDS32_TLS_IE_LO12);
13698 break;
13699 case R_NDS32_TLS_DESC_ADD:
13700 {
13701 uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13702 add_rt = N32_RT5 (insn);
13703 insn = N32_TYPE2 (LWI, add_rt, sethi_rt, 0);
13704 bfd_putb32 (insn, contents + irel->r_offset);
13705
13706 irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13707 }
13708 break;
13709 case R_NDS32_TLS_DESC_FUNC:
13710 bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13711 irel->r_info = ELF32_R_INFO(r_symndx,
13712 R_NDS32_RELAX_REMOVE);
13713 break;
13714 case R_NDS32_TLS_DESC_CALL:
13715 {
13716 uint32_t insn = N32_ALU1(ADD, REG_R0, add_rt,
13717 REG_TP);
13718 bfd_putb32 (insn, contents + irel->r_offset);
13719
13720 irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13721 }
13722 break;
13723 case R_NDS32_LOADSTORE:
13724 case R_NDS32_PTR:
13725 case R_NDS32_PTR_RESOLVED:
13726 case R_NDS32_NONE:
13727 case R_NDS32_LABEL:
13728 break;
13729 default:
13730 BFD_ASSERT(0);
13731 break;
13732 }
13733 break;
13734 case GOT_TLS_IEGP:
13735 switch (r_type)
13736 {
13737 case R_NDS32_TLS_DESC_HI20:
13738 irel->r_info = ELF32_R_INFO(r_symndx,
13739 R_NDS32_TLS_IEGP_HI20);
13740 break;
13741 case R_NDS32_TLS_DESC_LO12:
13742 irel->r_info = ELF32_R_INFO(r_symndx,
13743 R_NDS32_TLS_IEGP_LO12);
13744 break;
13745 case R_NDS32_TLS_DESC_ADD:
13746 {
13747 uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13748 add_rt = N32_RT5 (insn);
13749 insn = N32_MEM(LW, add_rt, sethi_rt, REG_GP, 0);
13750 bfd_putb32 (insn, contents + irel->r_offset);
13751
13752 irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13753 }
13754 break;
13755 case R_NDS32_TLS_DESC_FUNC:
13756 bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13757 irel->r_info = ELF32_R_INFO(r_symndx,
13758 R_NDS32_RELAX_REMOVE);
13759 break;
13760 case R_NDS32_TLS_DESC_CALL:
13761 {
13762 uint32_t insn = N32_ALU1(ADD, REG_R0, add_rt,
13763 REG_TP);
13764 bfd_putb32 (insn, contents + irel->r_offset);
13765
13766 irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13767 }
13768 break;
13769 case R_NDS32_LOADSTORE:
13770 case R_NDS32_PTR:
13771 case R_NDS32_PTR_RESOLVED:
13772 case R_NDS32_NONE:
13773 case R_NDS32_LABEL:
13774 break;
13775 default:
13776 BFD_ASSERT(0);
13777 break;
13778 }
13779 break;
13780 case GOT_TLS_LE:
13781 switch (r_type)
13782 {
13783 case R_NDS32_TLS_DESC_HI20:
13784 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_HI20);
13785 break;
13786 case R_NDS32_TLS_DESC_LO12:
13787 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_LO12);
13788 break;
13789 case R_NDS32_TLS_DESC_ADD:
13790 {
13791 uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13792
13793 add_rt = N32_RT5 (insn);
13794 insn = N32_ALU1 (ADD, REG_R0, sethi_rt, REG_TP);
13795 bfd_putb32 (insn, contents + irel->r_offset);
13796
13797 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_ADD);
13798 }
13799 break;
13800 case R_NDS32_TLS_DESC_FUNC:
13801 bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13802 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_RELAX_REMOVE);
13803 break;
13804 case R_NDS32_TLS_DESC_CALL:
13805 bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13806 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_RELAX_REMOVE);
13807 break;
13808 case R_NDS32_LOADSTORE:
13809 case R_NDS32_PTR:
13810 case R_NDS32_PTR_RESOLVED:
13811 case R_NDS32_NONE:
13812 case R_NDS32_LABEL:
13813 break;
13814 default:
13815 BFD_ASSERT(0);
13816 break;
13817 }
13818 break;
13819 default:
13820 break;
13821 }
13822 break;
13823 /* IEGP to IE/LE. */
13824 case GOT_TLS_IEGP:
13825 switch (eff_tls_type)
13826 {
13827 case GOT_TLS_IE:
13828 switch (r_type)
13829 {
13830 case R_NDS32_TLS_IEGP_HI20:
13831 irel->r_info = ELF32_R_INFO(r_symndx,
13832 R_NDS32_TLS_IE_HI20);
13833 break;
13834 case R_NDS32_TLS_IEGP_LO12:
13835 irel->r_info = ELF32_R_INFO(r_symndx,
13836 R_NDS32_TLS_IE_LO12);
13837 break;
13838 case R_NDS32_PTR_RESOLVED:
13839 {
13840 uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13841
13842 add_rt = N32_RT5 (insn);
13843 insn = N32_TYPE2 (LWI, add_rt, sethi_rt, 0);
13844 bfd_putb32 (insn, contents + irel->r_offset);
13845 }
13846 break;
13847 case R_NDS32_TLS_IEGP_LW:
13848 break;
13849 case R_NDS32_LOADSTORE:
13850 case R_NDS32_PTR:
13851 case R_NDS32_NONE:
13852 case R_NDS32_LABEL:
13853 break;
13854 default:
13855 BFD_ASSERT(0);
13856 break;
13857 }
13858 break;
13859 case GOT_TLS_LE:
13860 switch (r_type)
13861 {
13862 case R_NDS32_TLS_IEGP_HI20:
13863 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_HI20);
13864 break;
13865 case R_NDS32_TLS_IEGP_LO12:
13866 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_LO12);
13867 break;
13868 case R_NDS32_TLS_IEGP_LW:
13869 bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13870 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_RELAX_REMOVE);
13871 break;
13872 case R_NDS32_LOADSTORE:
13873 case R_NDS32_PTR:
13874 case R_NDS32_NONE:
13875 case R_NDS32_LABEL:
13876 case R_NDS32_PTR_RESOLVED:
13877 break;
13878 default:
13879 BFD_ASSERT(0);
13880 break;
13881 }
13882 break;
13883 default:
13884 break;
13885 }
13886 break;
13887 /* IE to LE. */
13888 case GOT_TLS_IE:
13889 switch (eff_tls_type)
13890 {
13891 case GOT_TLS_LE:
13892 switch (r_type)
13893 {
13894 case R_NDS32_TLS_IE_HI20:
13895 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_HI20);
13896 break;
13897 case R_NDS32_TLS_IE_LO12S2:
13898 {
13899 uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13900
13901 add_rt = N32_RT5 (insn);
13902 insn = N32_TYPE2 (ORI, add_rt, sethi_rt, 0);
13903 bfd_putb32 (insn, contents + irel->r_offset);
13904
13905 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_LO12);
13906 }
13907 break;
13908 case R_NDS32_LOADSTORE:
13909 case R_NDS32_PTR:
13910 case R_NDS32_NONE:
13911 case R_NDS32_LABEL:
13912 break;
13913 default:
13914 BFD_ASSERT(0);
13915 break;
13916 }
13917 break;
13918 default:
13919 break;
13920 }
13921 break;
13922 default:
13923 break;
13924 }
13925 }
13926 pNextSig = pNextSig->next_sibling;
13927 }
13928
13929 #if 1
13930 pNext = pNext->next;
13931 #else
13932 while (pNext)
13933 {
13934 if (pNext->id != cur_grp_id)
13935 break;
13936 pNext = pNext->next;
13937 }
13938 #endif
13939 }
13940
13941 finish:
13942 if (incontents)
13943 contents = NULL;
13944
13945 if (elf_section_data (insec)->relocs != internal_relocs)
13946 free (internal_relocs);
13947
13948 if (elf_section_data (insec)->this_hdr.contents != contents)
13949 free (contents);
13950
13951 if (symtab_hdr->contents != (bfd_byte *) local_syms)
13952 free (local_syms);
13953
13954 if (chain.next)
13955 {
13956 pNext = chain.next;
13957 relax_group_list_t *pDel;
13958 while (pNext)
13959 {
13960 pDel = pNext;
13961 pNext = pNext->next;
13962 free (pDel);
13963 }
13964 }
13965
13966 return result;
13967
13968 error_return:
13969 result = FALSE;
13970 goto finish;
13971 }
13972
13973 /* End TLS model conversion. */
13974
13975 #define ELF_ARCH bfd_arch_nds32
13976 #define ELF_MACHINE_CODE EM_NDS32
13977 #define ELF_MAXPAGESIZE 0x1000
13978 #define ELF_TARGET_ID NDS32_ELF_DATA
13979
13980 #define TARGET_BIG_SYM nds32_elf32_be_vec
13981 #define TARGET_BIG_NAME "elf32-nds32be"
13982 #define TARGET_LITTLE_SYM nds32_elf32_le_vec
13983 #define TARGET_LITTLE_NAME "elf32-nds32le"
13984
13985 #define elf_info_to_howto nds32_info_to_howto
13986 #define elf_info_to_howto_rel nds32_info_to_howto_rel
13987
13988 #define bfd_elf32_bfd_link_hash_table_create nds32_elf_link_hash_table_create
13989 #define bfd_elf32_bfd_merge_private_bfd_data nds32_elf_merge_private_bfd_data
13990 #define bfd_elf32_bfd_print_private_bfd_data nds32_elf_print_private_bfd_data
13991 #define bfd_elf32_bfd_relax_section nds32_elf_relax_section
13992 #define bfd_elf32_bfd_set_private_flags nds32_elf_set_private_flags
13993
13994 #define bfd_elf32_mkobject nds32_elf_mkobject
13995 #define elf_backend_action_discarded nds32_elf_action_discarded
13996 #define elf_backend_add_symbol_hook nds32_elf_add_symbol_hook
13997 #define elf_backend_check_relocs nds32_elf_check_relocs
13998 #define elf_backend_adjust_dynamic_symbol nds32_elf_adjust_dynamic_symbol
13999 #define elf_backend_create_dynamic_sections nds32_elf_create_dynamic_sections
14000 #define elf_backend_finish_dynamic_sections nds32_elf_finish_dynamic_sections
14001 #define elf_backend_finish_dynamic_symbol nds32_elf_finish_dynamic_symbol
14002 #define elf_backend_size_dynamic_sections nds32_elf_size_dynamic_sections
14003 #define elf_backend_relocate_section nds32_elf_relocate_section
14004 #define elf_backend_gc_mark_hook nds32_elf_gc_mark_hook
14005 #define elf_backend_grok_prstatus nds32_elf_grok_prstatus
14006 #define elf_backend_grok_psinfo nds32_elf_grok_psinfo
14007 #define elf_backend_reloc_type_class nds32_elf_reloc_type_class
14008 #define elf_backend_copy_indirect_symbol nds32_elf_copy_indirect_symbol
14009 #define elf_backend_link_output_symbol_hook nds32_elf_output_symbol_hook
14010 #define elf_backend_output_arch_syms nds32_elf_output_arch_syms
14011 #define elf_backend_object_p nds32_elf_object_p
14012 #define elf_backend_final_write_processing nds32_elf_final_write_processing
14013 #define elf_backend_special_sections nds32_elf_special_sections
14014 #define elf_backend_section_flags nds32_elf_section_flags
14015 #define bfd_elf32_bfd_get_relocated_section_contents \
14016 nds32_elf_get_relocated_section_contents
14017 #define bfd_elf32_bfd_is_target_special_symbol nds32_elf_is_target_special_symbol
14018 #define elf_backend_maybe_function_sym nds32_elf_maybe_function_sym
14019
14020 #define elf_backend_can_gc_sections 1
14021 #define elf_backend_can_refcount 1
14022 #define elf_backend_want_got_plt 1
14023 #define elf_backend_plt_readonly 1
14024 #define elf_backend_want_plt_sym 0
14025 #define elf_backend_got_header_size 12
14026 #define elf_backend_may_use_rel_p 1
14027 #define elf_backend_default_use_rela_p 1
14028 #define elf_backend_may_use_rela_p 1
14029 #define elf_backend_dtrel_excludes_plt 0
14030
14031 #include "elf32-target.h"
14032
14033 #undef ELF_MAXPAGESIZE
14034 #define ELF_MAXPAGESIZE 0x2000
14035
14036 #undef TARGET_BIG_SYM
14037 #define TARGET_BIG_SYM nds32_elf32_linux_be_vec
14038 #undef TARGET_BIG_NAME
14039 #define TARGET_BIG_NAME "elf32-nds32be-linux"
14040 #undef TARGET_LITTLE_SYM
14041 #define TARGET_LITTLE_SYM nds32_elf32_linux_le_vec
14042 #undef TARGET_LITTLE_NAME
14043 #define TARGET_LITTLE_NAME "elf32-nds32le-linux"
14044 #undef elf32_bed
14045 #define elf32_bed elf32_nds32_lin_bed
14046
14047 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.335881 seconds and 4 git commands to generate.