projects / deliverable / binutils-gdb.git / blob
? search:


8844166921110191938d2166a18d94251302c29b
[deliverable/binutils-gdb.git] / bfd / elf32-nds32.c
1 /* NDS32-specific support for 32-bit ELF.
2 Copyright (C) 2012-2018 Free Software Foundation, Inc.
3 Contributed by Andes Technology Corporation.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "bfd_stdint.h"
26 #include "bfdlink.h"
27 #include "libbfd.h"
28 #include "elf-bfd.h"
29 #include "libiberty.h"
30 #include "bfd_stdint.h"
31 #include "elf/nds32.h"
32 #include "opcode/nds32.h"
33 #include "elf32-nds32.h"
34 #include "opcode/cgen.h"
35 #include "../opcodes/nds32-opc.h"
36
37 /* Relocation HOWTO functions. */
38 static bfd_reloc_status_type nds32_elf_ignore_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type nds32_elf_9_pcrel_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type nds32_elf_hi20_reloc
43 (bfd *, arelent *, asymbol *, void *,
44 asection *, bfd *, char **);
45 static bfd_reloc_status_type nds32_elf_lo12_reloc
46 (bfd *, arelent *, asymbol *, void *,
47 asection *, bfd *, char **);
48 static bfd_reloc_status_type nds32_elf_generic_reloc
49 (bfd *, arelent *, asymbol *, void *,
50 asection *, bfd *, char **);
51 static bfd_reloc_status_type nds32_elf_sda15_reloc
52 (bfd *, arelent *, asymbol *, void *,
53 asection *, bfd *, char **);
54
55 /* Helper functions for HOWTO. */
56 static bfd_reloc_status_type nds32_elf_do_9_pcrel_reloc
57 (bfd *, reloc_howto_type *, asection *, bfd_byte *, bfd_vma,
58 asection *, bfd_vma, bfd_vma);
59
60 /* Nds32 helper functions. */
61 static bfd_vma calculate_memory_address
62 (bfd *, Elf_Internal_Rela *, Elf_Internal_Sym *, Elf_Internal_Shdr *);
63 static int nds32_get_section_contents (bfd *, asection *,
64 bfd_byte **, bfd_boolean);
65 static int nds32_get_local_syms (bfd *, asection *ATTRIBUTE_UNUSED,
66 Elf_Internal_Sym **);
67 static bfd_boolean nds32_relax_fp_as_gp
68 (struct bfd_link_info *link_info, bfd *abfd, asection *sec,
69 Elf_Internal_Rela *internal_relocs, Elf_Internal_Rela *irelend,
70 Elf_Internal_Sym *isymbuf);
71 static bfd_boolean nds32_fag_remove_unused_fpbase
72 (bfd *abfd, asection *sec, Elf_Internal_Rela *internal_relocs,
73 Elf_Internal_Rela *irelend);
74
75 enum
76 {
77 MACH_V1 = bfd_mach_n1h,
78 MACH_V2 = bfd_mach_n1h_v2,
79 MACH_V3 = bfd_mach_n1h_v3,
80 MACH_V3M = bfd_mach_n1h_v3m
81 };
82
83 #define MIN(a, b) ((a) > (b) ? (b) : (a))
84 #define MAX(a, b) ((a) > (b) ? (a) : (b))
85
86 /* The name of the dynamic interpreter. This is put in the .interp
87 section. */
88 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
89
90 #define NDS32_GUARD_SEC_P(flags) ((flags) & SEC_ALLOC \
91 && (flags) & SEC_LOAD \
92 && (flags) & SEC_READONLY)
93
94 /* The nop opcode we use. */
95 #define NDS32_NOP32 0x40000009
96 #define NDS32_NOP16 0x9200
97
98 /* The size in bytes of an entry in the procedure linkage table. */
99 #define PLT_ENTRY_SIZE 24
100 #define PLT_HEADER_SIZE 24
101
102 /* The first entry in a procedure linkage table are reserved,
103 and the initial contents are unimportant (we zero them out).
104 Subsequent entries look like this. */
105 #define PLT0_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(.got+4) */
106 #define PLT0_ENTRY_WORD1 0x58f78000 /* ori r15, r25, LO12(.got+4) */
107 #define PLT0_ENTRY_WORD2 0x05178000 /* lwi r17, [r15+0] */
108 #define PLT0_ENTRY_WORD3 0x04f78001 /* lwi r15, [r15+4] */
109 #define PLT0_ENTRY_WORD4 0x4a003c00 /* jr r15 */
110
111 /* $ta is change to $r15 (from $r25). */
112 #define PLT0_PIC_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(got[1]@GOT) */
113 #define PLT0_PIC_ENTRY_WORD1 0x58f78000 /* ori r15, r15, LO12(got[1]@GOT) */
114 #define PLT0_PIC_ENTRY_WORD2 0x40f7f400 /* add r15, gp, r15 */
115 #define PLT0_PIC_ENTRY_WORD3 0x05178000 /* lwi r17, [r15+0] */
116 #define PLT0_PIC_ENTRY_WORD4 0x04f78001 /* lwi r15, [r15+4] */
117 #define PLT0_PIC_ENTRY_WORD5 0x4a003c00 /* jr r15 */
118
119 #define PLT_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(&got[n+3]) */
120 #define PLT_ENTRY_WORD1 0x04f78000 /* lwi r15, r15, LO12(&got[n+3]) */
121 #define PLT_ENTRY_WORD2 0x4a003c00 /* jr r15 */
122 #define PLT_ENTRY_WORD3 0x45000000 /* movi r16, sizeof(RELA) * n */
123 #define PLT_ENTRY_WORD4 0x48000000 /* j .plt0. */
124
125 #define PLT_PIC_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(got[n+3]@GOT) */
126 #define PLT_PIC_ENTRY_WORD1 0x58f78000 /* ori r15, r15, LO12(got[n+3]@GOT) */
127 #define PLT_PIC_ENTRY_WORD2 0x38febc02 /* lw r15, [gp+r15] */
128 #define PLT_PIC_ENTRY_WORD3 0x4a003c00 /* jr r15 */
129 #define PLT_PIC_ENTRY_WORD4 0x45000000 /* movi r16, sizeof(RELA) * n */
130 #define PLT_PIC_ENTRY_WORD5 0x48000000 /* j .plt0 */
131
132 /* These are macros used to get the relocation accurate value. */
133 #define ACCURATE_8BIT_S1 (0x100)
134 #define ACCURATE_U9BIT_S1 (0x400)
135 #define ACCURATE_12BIT_S1 (0x2000)
136 #define ACCURATE_14BIT_S1 (0x4000)
137 #define ACCURATE_19BIT (0x40000)
138
139 /* These are macros used to get the relocation conservative value. */
140 #define CONSERVATIVE_8BIT_S1 (0x100 - 4)
141 #define CONSERVATIVE_14BIT_S1 (0x4000 - 4)
142 #define CONSERVATIVE_16BIT_S1 (0x10000 - 4)
143 #define CONSERVATIVE_24BIT_S1 (0x1000000 - 4)
144 /* These must be more conservative because the address may be in
145 different segment. */
146 #define CONSERVATIVE_15BIT (0x4000 - 0x1000)
147 #define CONSERVATIVE_15BIT_S1 (0x8000 - 0x1000)
148 #define CONSERVATIVE_15BIT_S2 (0x10000 - 0x1000)
149 #define CONSERVATIVE_19BIT (0x40000 - 0x1000)
150 #define CONSERVATIVE_20BIT (0x80000 - 0x1000)
151
152 /* Size of small data/bss sections, used to calculate SDA_BASE. */
153 static long got_size = 0;
154 static int is_SDA_BASE_set = 0;
155
156 /* Convert ELF-VER in eflags to string for debugging purpose. */
157 static const char *const nds32_elfver_strtab[] =
158 {
159 "ELF-1.2",
160 "ELF-1.3",
161 "ELF-1.4",
162 };
163
164 /* The nds32 linker needs to keep track of the number of relocs that it
165 decides to copy in check_relocs for each symbol. This is so that
166 it can discard PC relative relocs if it doesn't need them when
167 linking with -Bsymbolic. We store the information in a field
168 extending the regular ELF linker hash table. */
169
170 /* This structure keeps track of the number of PC relative relocs we
171 have copied for a given symbol. */
172
173 struct elf_nds32_pcrel_relocs_copied
174 {
175 /* Next section. */
176 struct elf_nds32_pcrel_relocs_copied *next;
177 /* A section in dynobj. */
178 asection *section;
179 /* Number of relocs copied in this section. */
180 bfd_size_type count;
181 };
182
183 enum elf_nds32_tls_type
184 {
185 GOT_UNKNOWN = (0),
186 GOT_NORMAL = (1 << 0),
187 GOT_TLS_LE = (1 << 1),
188 GOT_TLS_IE = (1 << 2),
189 GOT_TLS_IEGP = (1 << 3),
190 GOT_TLS_LD = (1 << 4),
191 GOT_TLS_GD = (1 << 5),
192 GOT_TLS_DESC = (1 << 6),
193 };
194
195 /* Nds32 ELF linker hash entry. */
196
197 struct elf_nds32_link_hash_entry
198 {
199 struct elf_link_hash_entry root;
200
201 /* Track dynamic relocs copied for this symbol. */
202 struct elf_dyn_relocs *dyn_relocs;
203
204 /* For checking relocation type. */
205 enum elf_nds32_tls_type tls_type;
206
207 int offset_to_gp;
208 };
209
210 /* Get the nds32 ELF linker hash table from a link_info structure. */
211
212 #define FP_BASE_NAME "_FP_BASE_"
213 static int check_start_export_sym = 0;
214
215 /* The offset for executable tls relaxation. */
216 #define TP_OFFSET 0x0
217
218 typedef struct
219 {
220 int min_id;
221 int max_id;
222 int count;
223 int bias;
224 int init;
225 } elf32_nds32_relax_group_t;
226
227 struct elf_nds32_obj_tdata
228 {
229 struct elf_obj_tdata root;
230
231 /* tls_type for each local got entry. */
232 char *local_got_tls_type;
233
234 /* GOTPLT entries for TLS descriptors. */
235 bfd_vma *local_tlsdesc_gotent;
236
237 /* for R_NDS32_RELAX_GROUP handling. */
238 elf32_nds32_relax_group_t relax_group;
239
240 unsigned int hdr_size;
241 int* offset_to_gp;
242 };
243
244 #define elf_nds32_tdata(bfd) \
245 ((struct elf_nds32_obj_tdata *) (bfd)->tdata.any)
246
247 #define elf32_nds32_local_got_tls_type(bfd) \
248 (elf_nds32_tdata (bfd)->local_got_tls_type)
249
250 #define elf32_nds32_local_gp_offset(bfd) \
251 (elf_nds32_tdata (bfd)->offset_to_gp)
252
253 #define elf32_nds32_hash_entry(ent) ((struct elf_nds32_link_hash_entry *)(ent))
254
255 #define elf32_nds32_relax_group_ptr(bfd) \
256 &(elf_nds32_tdata (bfd)->relax_group)
257
258 static bfd_boolean
259 nds32_elf_mkobject (bfd *abfd)
260 {
261 return bfd_elf_allocate_object (abfd, sizeof (struct elf_nds32_obj_tdata),
262 NDS32_ELF_DATA);
263 }
264
265 /* Relocations used for relocation. */
266 /* Define HOWTO2 (for relocation) and HOWTO3 (for relaxation) to
267 initialize array nds32_elf_howto_table in any order. The benefit
268 is that we can add any new relocations with any numbers and don't
269 need to fill the gap by lots of EMPTY_HOWTO. */
270 #define HOWTO2(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
271 [C] = HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC)
272
273 static reloc_howto_type nds32_elf_howto_table[] =
274 {
275 /* This reloc does nothing. */
276 HOWTO2 (R_NDS32_NONE, /* type */
277 0, /* rightshift */
278 2, /* size (0 = byte, 1 = short, 2 = long) */
279 32, /* bitsize */
280 FALSE, /* pc_relative */
281 0, /* bitpos */
282 complain_overflow_bitfield,/* complain_on_overflow */
283 bfd_elf_generic_reloc, /* special_function */
284 "R_NDS32_NONE", /* name */
285 FALSE, /* partial_inplace */
286 0, /* src_mask */
287 0, /* dst_mask */
288 FALSE), /* pcrel_offset */
289
290 /* A 16 bit absolute relocation. */
291 HOWTO2 (R_NDS32_16, /* type */
292 0, /* rightshift */
293 1, /* size (0 = byte, 1 = short, 2 = long) */
294 16, /* bitsize */
295 FALSE, /* pc_relative */
296 0, /* bitpos */
297 complain_overflow_bitfield,/* complain_on_overflow */
298 nds32_elf_generic_reloc,/* special_function */
299 "R_NDS32_16", /* name */
300 FALSE, /* partial_inplace */
301 0xffff, /* src_mask */
302 0xffff, /* dst_mask */
303 FALSE), /* pcrel_offset */
304
305 /* A 32 bit absolute relocation. */
306 HOWTO2 (R_NDS32_32, /* type */
307 0, /* rightshift */
308 2, /* size (0 = byte, 1 = short, 2 = long) */
309 32, /* bitsize */
310 FALSE, /* pc_relative */
311 0, /* bitpos */
312 complain_overflow_bitfield,/* complain_on_overflow */
313 nds32_elf_generic_reloc,/* special_function */
314 "R_NDS32_32", /* name */
315 FALSE, /* partial_inplace */
316 0xffffffff, /* src_mask */
317 0xffffffff, /* dst_mask */
318 FALSE), /* pcrel_offset */
319
320 /* A 20 bit address. */
321 HOWTO2 (R_NDS32_20, /* type */
322 0, /* rightshift */
323 2, /* size (0 = byte, 1 = short, 2 = long) */
324 20, /* bitsize */
325 FALSE, /* pc_relative */
326 0, /* bitpos */
327 complain_overflow_unsigned,/* complain_on_overflow */
328 nds32_elf_generic_reloc,/* special_function */
329 "R_NDS32_20", /* name */
330 FALSE, /* partial_inplace */
331 0xfffff, /* src_mask */
332 0xfffff, /* dst_mask */
333 FALSE), /* pcrel_offset */
334
335 /* An PC Relative 9-bit relocation, shifted by 2.
336 This reloc is complicated because relocations are relative to pc & -4.
337 i.e. branches in the right insn slot use the address of the left insn
338 slot for pc. */
339 /* It's not clear whether this should have partial_inplace set or not.
340 Branch relaxing in the assembler can store the addend in the insn,
341 and if bfd_install_relocation gets called the addend may get added
342 again. */
343 HOWTO2 (R_NDS32_9_PCREL, /* type */
344 1, /* rightshift */
345 1, /* size (0 = byte, 1 = short, 2 = long) */
346 8, /* bitsize */
347 TRUE, /* pc_relative */
348 0, /* bitpos */
349 complain_overflow_signed,/* complain_on_overflow */
350 nds32_elf_9_pcrel_reloc,/* special_function */
351 "R_NDS32_9_PCREL", /* name */
352 FALSE, /* partial_inplace */
353 0xff, /* src_mask */
354 0xff, /* dst_mask */
355 TRUE), /* pcrel_offset */
356
357 /* A relative 15 bit relocation, right shifted by 1. */
358 HOWTO2 (R_NDS32_15_PCREL, /* type */
359 1, /* rightshift */
360 2, /* size (0 = byte, 1 = short, 2 = long) */
361 14, /* bitsize */
362 TRUE, /* pc_relative */
363 0, /* bitpos */
364 complain_overflow_signed,/* complain_on_overflow */
365 bfd_elf_generic_reloc, /* special_function */
366 "R_NDS32_15_PCREL", /* name */
367 FALSE, /* partial_inplace */
368 0x3fff, /* src_mask */
369 0x3fff, /* dst_mask */
370 TRUE), /* pcrel_offset */
371
372 /* A relative 17 bit relocation, right shifted by 1. */
373 HOWTO2 (R_NDS32_17_PCREL, /* type */
374 1, /* rightshift */
375 2, /* size (0 = byte, 1 = short, 2 = long) */
376 16, /* bitsize */
377 TRUE, /* pc_relative */
378 0, /* bitpos */
379 complain_overflow_signed,/* complain_on_overflow */
380 bfd_elf_generic_reloc, /* special_function */
381 "R_NDS32_17_PCREL", /* name */
382 FALSE, /* partial_inplace */
383 0xffff, /* src_mask */
384 0xffff, /* dst_mask */
385 TRUE), /* pcrel_offset */
386
387 /* A relative 25 bit relocation, right shifted by 1. */
388 /* It's not clear whether this should have partial_inplace set or not.
389 Branch relaxing in the assembler can store the addend in the insn,
390 and if bfd_install_relocation gets called the addend may get added
391 again. */
392 HOWTO2 (R_NDS32_25_PCREL, /* type */
393 1, /* rightshift */
394 2, /* size (0 = byte, 1 = short, 2 = long) */
395 24, /* bitsize */
396 TRUE, /* pc_relative */
397 0, /* bitpos */
398 complain_overflow_signed,/* complain_on_overflow */
399 bfd_elf_generic_reloc, /* special_function */
400 "R_NDS32_25_PCREL", /* name */
401 FALSE, /* partial_inplace */
402 0xffffff, /* src_mask */
403 0xffffff, /* dst_mask */
404 TRUE), /* pcrel_offset */
405
406 /* High 20 bits of address when lower 12 is or'd in. */
407 HOWTO2 (R_NDS32_HI20, /* type */
408 12, /* rightshift */
409 2, /* size (0 = byte, 1 = short, 2 = long) */
410 20, /* bitsize */
411 FALSE, /* pc_relative */
412 0, /* bitpos */
413 complain_overflow_dont,/* complain_on_overflow */
414 nds32_elf_hi20_reloc, /* special_function */
415 "R_NDS32_HI20", /* name */
416 FALSE, /* partial_inplace */
417 0x000fffff, /* src_mask */
418 0x000fffff, /* dst_mask */
419 FALSE), /* pcrel_offset */
420
421 /* Lower 12 bits of address. */
422 HOWTO2 (R_NDS32_LO12S3, /* type */
423 3, /* rightshift */
424 2, /* size (0 = byte, 1 = short, 2 = long) */
425 9, /* bitsize */
426 FALSE, /* pc_relative */
427 0, /* bitpos */
428 complain_overflow_dont,/* complain_on_overflow */
429 nds32_elf_lo12_reloc, /* special_function */
430 "R_NDS32_LO12S3", /* name */
431 FALSE, /* partial_inplace */
432 0x000001ff, /* src_mask */
433 0x000001ff, /* dst_mask */
434 FALSE), /* pcrel_offset */
435
436 /* Lower 12 bits of address. */
437 HOWTO2 (R_NDS32_LO12S2, /* type */
438 2, /* rightshift */
439 2, /* size (0 = byte, 1 = short, 2 = long) */
440 10, /* bitsize */
441 FALSE, /* pc_relative */
442 0, /* bitpos */
443 complain_overflow_dont,/* complain_on_overflow */
444 nds32_elf_lo12_reloc, /* special_function */
445 "R_NDS32_LO12S2", /* name */
446 FALSE, /* partial_inplace */
447 0x000003ff, /* src_mask */
448 0x000003ff, /* dst_mask */
449 FALSE), /* pcrel_offset */
450
451 /* Lower 12 bits of address. */
452 HOWTO2 (R_NDS32_LO12S1, /* type */
453 1, /* rightshift */
454 2, /* size (0 = byte, 1 = short, 2 = long) */
455 11, /* bitsize */
456 FALSE, /* pc_relative */
457 0, /* bitpos */
458 complain_overflow_dont,/* complain_on_overflow */
459 nds32_elf_lo12_reloc, /* special_function */
460 "R_NDS32_LO12S1", /* name */
461 FALSE, /* partial_inplace */
462 0x000007ff, /* src_mask */
463 0x000007ff, /* dst_mask */
464 FALSE), /* pcrel_offset */
465
466 /* Lower 12 bits of address. */
467 HOWTO2 (R_NDS32_LO12S0, /* type */
468 0, /* rightshift */
469 2, /* size (0 = byte, 1 = short, 2 = long) */
470 12, /* bitsize */
471 FALSE, /* pc_relative */
472 0, /* bitpos */
473 complain_overflow_dont,/* complain_on_overflow */
474 nds32_elf_lo12_reloc, /* special_function */
475 "R_NDS32_LO12S0", /* name */
476 FALSE, /* partial_inplace */
477 0x00000fff, /* src_mask */
478 0x00000fff, /* dst_mask */
479 FALSE), /* pcrel_offset */
480
481 /* Small data area 15 bits offset. */
482 HOWTO2 (R_NDS32_SDA15S3, /* type */
483 3, /* rightshift */
484 2, /* size (0 = byte, 1 = short, 2 = long) */
485 15, /* bitsize */
486 FALSE, /* pc_relative */
487 0, /* bitpos */
488 complain_overflow_signed,/* complain_on_overflow */
489 nds32_elf_sda15_reloc, /* special_function */
490 "R_NDS32_SDA15S3", /* name */
491 FALSE, /* partial_inplace */
492 0x00007fff, /* src_mask */
493 0x00007fff, /* dst_mask */
494 FALSE), /* pcrel_offset */
495
496 /* Small data area 15 bits offset. */
497 HOWTO2 (R_NDS32_SDA15S2, /* type */
498 2, /* rightshift */
499 2, /* size (0 = byte, 1 = short, 2 = long) */
500 15, /* bitsize */
501 FALSE, /* pc_relative */
502 0, /* bitpos */
503 complain_overflow_signed,/* complain_on_overflow */
504 nds32_elf_sda15_reloc, /* special_function */
505 "R_NDS32_SDA15S2", /* name */
506 FALSE, /* partial_inplace */
507 0x00007fff, /* src_mask */
508 0x00007fff, /* dst_mask */
509 FALSE), /* pcrel_offset */
510
511 /* Small data area 15 bits offset. */
512 HOWTO2 (R_NDS32_SDA15S1, /* type */
513 1, /* rightshift */
514 2, /* size (0 = byte, 1 = short, 2 = long) */
515 15, /* bitsize */
516 FALSE, /* pc_relative */
517 0, /* bitpos */
518 complain_overflow_signed,/* complain_on_overflow */
519 nds32_elf_sda15_reloc, /* special_function */
520 "R_NDS32_SDA15S1", /* name */
521 FALSE, /* partial_inplace */
522 0x00007fff, /* src_mask */
523 0x00007fff, /* dst_mask */
524 FALSE), /* pcrel_offset */
525
526 /* Small data area 15 bits offset. */
527 HOWTO2 (R_NDS32_SDA15S0, /* type */
528 0, /* rightshift */
529 2, /* size (0 = byte, 1 = short, 2 = long) */
530 15, /* bitsize */
531 FALSE, /* pc_relative */
532 0, /* bitpos */
533 complain_overflow_signed,/* complain_on_overflow */
534 nds32_elf_sda15_reloc, /* special_function */
535 "R_NDS32_SDA15S0", /* name */
536 FALSE, /* partial_inplace */
537 0x00007fff, /* src_mask */
538 0x00007fff, /* dst_mask */
539 FALSE), /* pcrel_offset */
540
541 /* GNU extension to record C++ vtable hierarchy */
542 HOWTO2 (R_NDS32_GNU_VTINHERIT,/* type */
543 0, /* rightshift */
544 2, /* size (0 = byte, 1 = short, 2 = long) */
545 0, /* bitsize */
546 FALSE, /* pc_relative */
547 0, /* bitpos */
548 complain_overflow_dont,/* complain_on_overflow */
549 NULL, /* special_function */
550 "R_NDS32_GNU_VTINHERIT",/* name */
551 FALSE, /* partial_inplace */
552 0, /* src_mask */
553 0, /* dst_mask */
554 FALSE), /* pcrel_offset */
555
556 /* GNU extension to record C++ vtable member usage */
557 HOWTO2 (R_NDS32_GNU_VTENTRY, /* type */
558 0, /* rightshift */
559 2, /* size (0 = byte, 1 = short, 2 = long) */
560 0, /* bitsize */
561 FALSE, /* pc_relative */
562 0, /* bitpos */
563 complain_overflow_dont,/* complain_on_overflow */
564 _bfd_elf_rel_vtable_reloc_fn,/* special_function */
565 "R_NDS32_GNU_VTENTRY", /* name */
566 FALSE, /* partial_inplace */
567 0, /* src_mask */
568 0, /* dst_mask */
569 FALSE), /* pcrel_offset */
570
571 /* A 16 bit absolute relocation. */
572 HOWTO2 (R_NDS32_16_RELA, /* type */
573 0, /* rightshift */
574 1, /* size (0 = byte, 1 = short, 2 = long) */
575 16, /* bitsize */
576 FALSE, /* pc_relative */
577 0, /* bitpos */
578 complain_overflow_bitfield,/* complain_on_overflow */
579 bfd_elf_generic_reloc, /* special_function */
580 "R_NDS32_16_RELA", /* name */
581 FALSE, /* partial_inplace */
582 0xffff, /* src_mask */
583 0xffff, /* dst_mask */
584 FALSE), /* pcrel_offset */
585
586 /* A 32 bit absolute relocation. */
587 HOWTO2 (R_NDS32_32_RELA, /* type */
588 0, /* rightshift */
589 2, /* size (0 = byte, 1 = short, 2 = long) */
590 32, /* bitsize */
591 FALSE, /* pc_relative */
592 0, /* bitpos */
593 complain_overflow_bitfield,/* complain_on_overflow */
594 bfd_elf_generic_reloc, /* special_function */
595 "R_NDS32_32_RELA", /* name */
596 FALSE, /* partial_inplace */
597 0xffffffff, /* src_mask */
598 0xffffffff, /* dst_mask */
599 FALSE), /* pcrel_offset */
600
601 /* A 20 bit address. */
602 HOWTO2 (R_NDS32_20_RELA, /* type */
603 0, /* rightshift */
604 2, /* size (0 = byte, 1 = short, 2 = long) */
605 20, /* bitsize */
606 FALSE, /* pc_relative */
607 0, /* bitpos */
608 complain_overflow_signed,/* complain_on_overflow */
609 bfd_elf_generic_reloc, /* special_function */
610 "R_NDS32_20_RELA", /* name */
611 FALSE, /* partial_inplace */
612 0xfffff, /* src_mask */
613 0xfffff, /* dst_mask */
614 FALSE), /* pcrel_offset */
615
616 HOWTO2 (R_NDS32_9_PCREL_RELA, /* type */
617 1, /* rightshift */
618 1, /* size (0 = byte, 1 = short, 2 = long) */
619 8, /* bitsize */
620 TRUE, /* pc_relative */
621 0, /* bitpos */
622 complain_overflow_signed,/* complain_on_overflow */
623 bfd_elf_generic_reloc, /* special_function */
624 "R_NDS32_9_PCREL_RELA",/* name */
625 FALSE, /* partial_inplace */
626 0xff, /* src_mask */
627 0xff, /* dst_mask */
628 TRUE), /* pcrel_offset */
629
630 /* A relative 15 bit relocation, right shifted by 1. */
631 HOWTO2 (R_NDS32_15_PCREL_RELA,/* type */
632 1, /* rightshift */
633 2, /* size (0 = byte, 1 = short, 2 = long) */
634 14, /* bitsize */
635 TRUE, /* pc_relative */
636 0, /* bitpos */
637 complain_overflow_signed,/* complain_on_overflow */
638 bfd_elf_generic_reloc, /* special_function */
639 "R_NDS32_15_PCREL_RELA",/* name */
640 FALSE, /* partial_inplace */
641 0x3fff, /* src_mask */
642 0x3fff, /* dst_mask */
643 TRUE), /* pcrel_offset */
644
645 /* A relative 17 bit relocation, right shifted by 1. */
646 HOWTO2 (R_NDS32_17_PCREL_RELA,/* type */
647 1, /* rightshift */
648 2, /* size (0 = byte, 1 = short, 2 = long) */
649 16, /* bitsize */
650 TRUE, /* pc_relative */
651 0, /* bitpos */
652 complain_overflow_signed,/* complain_on_overflow */
653 bfd_elf_generic_reloc, /* special_function */
654 "R_NDS32_17_PCREL_RELA",/* name */
655 FALSE, /* partial_inplace */
656 0xffff, /* src_mask */
657 0xffff, /* dst_mask */
658 TRUE), /* pcrel_offset */
659
660 /* A relative 25 bit relocation, right shifted by 2. */
661 HOWTO2 (R_NDS32_25_PCREL_RELA,/* type */
662 1, /* rightshift */
663 2, /* size (0 = byte, 1 = short, 2 = long) */
664 24, /* bitsize */
665 TRUE, /* pc_relative */
666 0, /* bitpos */
667 complain_overflow_signed,/* complain_on_overflow */
668 bfd_elf_generic_reloc, /* special_function */
669 "R_NDS32_25_PCREL_RELA",/* name */
670 FALSE, /* partial_inplace */
671 0xffffff, /* src_mask */
672 0xffffff, /* dst_mask */
673 TRUE), /* pcrel_offset */
674
675 /* High 20 bits of address when lower 16 is or'd in. */
676 HOWTO2 (R_NDS32_HI20_RELA, /* type */
677 12, /* rightshift */
678 2, /* size (0 = byte, 1 = short, 2 = long) */
679 20, /* bitsize */
680 FALSE, /* pc_relative */
681 0, /* bitpos */
682 complain_overflow_dont,/* complain_on_overflow */
683 bfd_elf_generic_reloc, /* special_function */
684 "R_NDS32_HI20_RELA", /* name */
685 FALSE, /* partial_inplace */
686 0x000fffff, /* src_mask */
687 0x000fffff, /* dst_mask */
688 FALSE), /* pcrel_offset */
689
690 /* Lower 12 bits of address. */
691 HOWTO2 (R_NDS32_LO12S3_RELA, /* type */
692 3, /* rightshift */
693 2, /* size (0 = byte, 1 = short, 2 = long) */
694 9, /* bitsize */
695 FALSE, /* pc_relative */
696 0, /* bitpos */
697 complain_overflow_dont,/* complain_on_overflow */
698 bfd_elf_generic_reloc, /* special_function */
699 "R_NDS32_LO12S3_RELA", /* name */
700 FALSE, /* partial_inplace */
701 0x000001ff, /* src_mask */
702 0x000001ff, /* dst_mask */
703 FALSE), /* pcrel_offset */
704
705 /* Lower 12 bits of address. */
706 HOWTO2 (R_NDS32_LO12S2_RELA, /* type */
707 2, /* rightshift */
708 2, /* size (0 = byte, 1 = short, 2 = long) */
709 10, /* bitsize */
710 FALSE, /* pc_relative */
711 0, /* bitpos */
712 complain_overflow_dont,/* complain_on_overflow */
713 bfd_elf_generic_reloc, /* special_function */
714 "R_NDS32_LO12S2_RELA", /* name */
715 FALSE, /* partial_inplace */
716 0x000003ff, /* src_mask */
717 0x000003ff, /* dst_mask */
718 FALSE), /* pcrel_offset */
719
720 /* Lower 12 bits of address. */
721 HOWTO2 (R_NDS32_LO12S1_RELA, /* type */
722 1, /* rightshift */
723 2, /* size (0 = byte, 1 = short, 2 = long) */
724 11, /* bitsize */
725 FALSE, /* pc_relative */
726 0, /* bitpos */
727 complain_overflow_dont,/* complain_on_overflow */
728 bfd_elf_generic_reloc, /* special_function */
729 "R_NDS32_LO12S1_RELA", /* name */
730 FALSE, /* partial_inplace */
731 0x000007ff, /* src_mask */
732 0x000007ff, /* dst_mask */
733 FALSE), /* pcrel_offset */
734
735 /* Lower 12 bits of address. */
736 HOWTO2 (R_NDS32_LO12S0_RELA, /* type */
737 0, /* rightshift */
738 2, /* size (0 = byte, 1 = short, 2 = long) */
739 12, /* bitsize */
740 FALSE, /* pc_relative */
741 0, /* bitpos */
742 complain_overflow_dont,/* complain_on_overflow */
743 bfd_elf_generic_reloc, /* special_function */
744 "R_NDS32_LO12S0_RELA", /* name */
745 FALSE, /* partial_inplace */
746 0x00000fff, /* src_mask */
747 0x00000fff, /* dst_mask */
748 FALSE), /* pcrel_offset */
749
750 /* Small data area 15 bits offset. */
751 HOWTO2 (R_NDS32_SDA15S3_RELA, /* type */
752 3, /* rightshift */
753 2, /* size (0 = byte, 1 = short, 2 = long) */
754 15, /* bitsize */
755 FALSE, /* pc_relative */
756 0, /* bitpos */
757 complain_overflow_signed,/* complain_on_overflow */
758 bfd_elf_generic_reloc, /* special_function */
759 "R_NDS32_SDA15S3_RELA",/* name */
760 FALSE, /* partial_inplace */
761 0x00007fff, /* src_mask */
762 0x00007fff, /* dst_mask */
763 FALSE), /* pcrel_offset */
764
765 /* Small data area 15 bits offset. */
766 HOWTO2 (R_NDS32_SDA15S2_RELA, /* type */
767 2, /* rightshift */
768 2, /* size (0 = byte, 1 = short, 2 = long) */
769 15, /* bitsize */
770 FALSE, /* pc_relative */
771 0, /* bitpos */
772 complain_overflow_signed,/* complain_on_overflow */
773 bfd_elf_generic_reloc, /* special_function */
774 "R_NDS32_SDA15S2_RELA",/* name */
775 FALSE, /* partial_inplace */
776 0x00007fff, /* src_mask */
777 0x00007fff, /* dst_mask */
778 FALSE), /* pcrel_offset */
779
780 HOWTO2 (R_NDS32_SDA15S1_RELA, /* type */
781 1, /* rightshift */
782 2, /* size (0 = byte, 1 = short, 2 = long) */
783 15, /* bitsize */
784 FALSE, /* pc_relative */
785 0, /* bitpos */
786 complain_overflow_signed,/* complain_on_overflow */
787 bfd_elf_generic_reloc, /* special_function */
788 "R_NDS32_SDA15S1_RELA",/* name */
789 FALSE, /* partial_inplace */
790 0x00007fff, /* src_mask */
791 0x00007fff, /* dst_mask */
792 FALSE), /* pcrel_offset */
793
794 HOWTO2 (R_NDS32_SDA15S0_RELA, /* type */
795 0, /* rightshift */
796 2, /* size (0 = byte, 1 = short, 2 = long) */
797 15, /* bitsize */
798 FALSE, /* pc_relative */
799 0, /* bitpos */
800 complain_overflow_signed,/* complain_on_overflow */
801 bfd_elf_generic_reloc, /* special_function */
802 "R_NDS32_SDA15S0_RELA",/* name */
803 FALSE, /* partial_inplace */
804 0x00007fff, /* src_mask */
805 0x00007fff, /* dst_mask */
806 FALSE), /* pcrel_offset */
807
808 /* GNU extension to record C++ vtable hierarchy */
809 HOWTO2 (R_NDS32_RELA_GNU_VTINHERIT,/* type */
810 0, /* rightshift */
811 2, /* size (0 = byte, 1 = short, 2 = long) */
812 0, /* bitsize */
813 FALSE, /* pc_relative */
814 0, /* bitpos */
815 complain_overflow_dont,/* complain_on_overflow */
816 NULL, /* special_function */
817 "R_NDS32_RELA_GNU_VTINHERIT",/* name */
818 FALSE, /* partial_inplace */
819 0, /* src_mask */
820 0, /* dst_mask */
821 FALSE), /* pcrel_offset */
822
823 /* GNU extension to record C++ vtable member usage */
824 HOWTO2 (R_NDS32_RELA_GNU_VTENTRY,/* type */
825 0, /* rightshift */
826 2, /* size (0 = byte, 1 = short, 2 = long) */
827 0, /* bitsize */
828 FALSE, /* pc_relative */
829 0, /* bitpos */
830 complain_overflow_dont,/* complain_on_overflow */
831 _bfd_elf_rel_vtable_reloc_fn,/* special_function */
832 "R_NDS32_RELA_GNU_VTENTRY",/* name */
833 FALSE, /* partial_inplace */
834 0, /* src_mask */
835 0, /* dst_mask */
836 FALSE), /* pcrel_offset */
837
838 /* Like R_NDS32_20, but referring to the GOT table entry for
839 the symbol. */
840 HOWTO2 (R_NDS32_GOT20, /* type */
841 0, /* rightshift */
842 2, /* size (0 = byte, 1 = short, 2 = long) */
843 20, /* bitsize */
844 FALSE, /* pc_relative */
845 0, /* bitpos */
846 complain_overflow_signed,/* complain_on_overflow */
847 bfd_elf_generic_reloc, /* special_function */
848 "R_NDS32_GOT20", /* name */
849 FALSE, /* partial_inplace */
850 0xfffff, /* src_mask */
851 0xfffff, /* dst_mask */
852 FALSE), /* pcrel_offset */
853
854 /* Like R_NDS32_PCREL, but referring to the procedure linkage table
855 entry for the symbol. */
856 HOWTO2 (R_NDS32_25_PLTREL, /* type */
857 1, /* rightshift */
858 2, /* size (0 = byte, 1 = short, 2 = long) */
859 24, /* bitsize */
860 TRUE, /* pc_relative */
861 0, /* bitpos */
862 complain_overflow_signed,/* complain_on_overflow */
863 bfd_elf_generic_reloc, /* special_function */
864 "R_NDS32_25_PLTREL", /* name */
865 FALSE, /* partial_inplace */
866 0xffffff, /* src_mask */
867 0xffffff, /* dst_mask */
868 TRUE), /* pcrel_offset */
869
870 /* This is used only by the dynamic linker. The symbol should exist
871 both in the object being run and in some shared library. The
872 dynamic linker copies the data addressed by the symbol from the
873 shared library into the object, because the object being
874 run has to have the data at some particular address. */
875 HOWTO2 (R_NDS32_COPY, /* type */
876 0, /* rightshift */
877 2, /* size (0 = byte, 1 = short, 2 = long) */
878 32, /* bitsize */
879 FALSE, /* pc_relative */
880 0, /* bitpos */
881 complain_overflow_bitfield,/* complain_on_overflow */
882 bfd_elf_generic_reloc, /* special_function */
883 "R_NDS32_COPY", /* name */
884 FALSE, /* partial_inplace */
885 0xffffffff, /* src_mask */
886 0xffffffff, /* dst_mask */
887 FALSE), /* pcrel_offset */
888
889 /* Like R_NDS32_20, but used when setting global offset table
890 entries. */
891 HOWTO2 (R_NDS32_GLOB_DAT, /* type */
892 0, /* rightshift */
893 2, /* size (0 = byte, 1 = short, 2 = long) */
894 32, /* bitsize */
895 FALSE, /* pc_relative */
896 0, /* bitpos */
897 complain_overflow_bitfield,/* complain_on_overflow */
898 bfd_elf_generic_reloc, /* special_function */
899 "R_NDS32_GLOB_DAT", /* name */
900 FALSE, /* partial_inplace */
901 0xffffffff, /* src_mask */
902 0xffffffff, /* dst_mask */
903 FALSE), /* pcrel_offset */
904
905 /* Marks a procedure linkage table entry for a symbol. */
906 HOWTO2 (R_NDS32_JMP_SLOT, /* type */
907 0, /* rightshift */
908 2, /* size (0 = byte, 1 = short, 2 = long) */
909 32, /* bitsize */
910 FALSE, /* pc_relative */
911 0, /* bitpos */
912 complain_overflow_bitfield,/* complain_on_overflow */
913 bfd_elf_generic_reloc, /* special_function */
914 "R_NDS32_JMP_SLOT", /* name */
915 FALSE, /* partial_inplace */
916 0xffffffff, /* src_mask */
917 0xffffffff, /* dst_mask */
918 FALSE), /* pcrel_offset */
919
920 /* Used only by the dynamic linker. When the object is run, this
921 longword is set to the load address of the object, plus the
922 addend. */
923 HOWTO2 (R_NDS32_RELATIVE, /* type */
924 0, /* rightshift */
925 2, /* size (0 = byte, 1 = short, 2 = long) */
926 32, /* bitsize */
927 FALSE, /* pc_relative */
928 0, /* bitpos */
929 complain_overflow_bitfield,/* complain_on_overflow */
930 bfd_elf_generic_reloc, /* special_function */
931 "R_NDS32_RELATIVE", /* name */
932 FALSE, /* partial_inplace */
933 0xffffffff, /* src_mask */
934 0xffffffff, /* dst_mask */
935 FALSE), /* pcrel_offset */
936
937 HOWTO2 (R_NDS32_GOTOFF, /* type */
938 0, /* rightshift */
939 2, /* size (0 = byte, 1 = short, 2 = long) */
940 20, /* bitsize */
941 FALSE, /* pc_relative */
942 0, /* bitpos */
943 complain_overflow_signed,/* complain_on_overflow */
944 bfd_elf_generic_reloc, /* special_function */
945 "R_NDS32_GOTOFF", /* name */
946 FALSE, /* partial_inplace */
947 0xfffff, /* src_mask */
948 0xfffff, /* dst_mask */
949 FALSE), /* pcrel_offset */
950
951 /* An PC Relative 20-bit relocation used when setting PIC offset
952 table register. */
953 HOWTO2 (R_NDS32_GOTPC20, /* type */
954 0, /* rightshift */
955 2, /* size (0 = byte, 1 = short, 2 = long) */
956 20, /* bitsize */
957 TRUE, /* pc_relative */
958 0, /* bitpos */
959 complain_overflow_signed,/* complain_on_overflow */
960 bfd_elf_generic_reloc, /* special_function */
961 "R_NDS32_GOTPC20", /* name */
962 FALSE, /* partial_inplace */
963 0xfffff, /* src_mask */
964 0xfffff, /* dst_mask */
965 TRUE), /* pcrel_offset */
966
967 /* Like R_NDS32_HI20, but referring to the GOT table entry for
968 the symbol. */
969 HOWTO2 (R_NDS32_GOT_HI20, /* type */
970 12, /* rightshift */
971 2, /* size (0 = byte, 1 = short, 2 = long) */
972 20, /* bitsize */
973 FALSE, /* pc_relative */
974 0, /* bitpos */
975 complain_overflow_dont,/* complain_on_overflow */
976 bfd_elf_generic_reloc, /* special_function */
977 "R_NDS32_GOT_HI20", /* name */
978 FALSE, /* partial_inplace */
979 0x000fffff, /* src_mask */
980 0x000fffff, /* dst_mask */
981 FALSE), /* pcrel_offset */
982 HOWTO2 (R_NDS32_GOT_LO12, /* type */
983 0, /* rightshift */
984 2, /* size (0 = byte, 1 = short, 2 = long) */
985 12, /* bitsize */
986 FALSE, /* pc_relative */
987 0, /* bitpos */
988 complain_overflow_dont,/* complain_on_overflow */
989 bfd_elf_generic_reloc, /* special_function */
990 "R_NDS32_GOT_LO12", /* name */
991 FALSE, /* partial_inplace */
992 0x00000fff, /* src_mask */
993 0x00000fff, /* dst_mask */
994 FALSE), /* pcrel_offset */
995
996 /* An PC Relative relocation used when setting PIC offset table register.
997 Like R_NDS32_HI20, but referring to the GOT table entry for
998 the symbol. */
999 HOWTO2 (R_NDS32_GOTPC_HI20, /* type */
1000 12, /* rightshift */
1001 2, /* size (0 = byte, 1 = short, 2 = long) */
1002 20, /* bitsize */
1003 FALSE, /* pc_relative */
1004 0, /* bitpos */
1005 complain_overflow_dont,/* complain_on_overflow */
1006 bfd_elf_generic_reloc, /* special_function */
1007 "R_NDS32_GOTPC_HI20", /* name */
1008 FALSE, /* partial_inplace */
1009 0x000fffff, /* src_mask */
1010 0x000fffff, /* dst_mask */
1011 TRUE), /* pcrel_offset */
1012 HOWTO2 (R_NDS32_GOTPC_LO12, /* type */
1013 0, /* rightshift */
1014 2, /* size (0 = byte, 1 = short, 2 = long) */
1015 12, /* bitsize */
1016 FALSE, /* pc_relative */
1017 0, /* bitpos */
1018 complain_overflow_dont,/* complain_on_overflow */
1019 bfd_elf_generic_reloc, /* special_function */
1020 "R_NDS32_GOTPC_LO12", /* name */
1021 FALSE, /* partial_inplace */
1022 0x00000fff, /* src_mask */
1023 0x00000fff, /* dst_mask */
1024 TRUE), /* pcrel_offset */
1025
1026 HOWTO2 (R_NDS32_GOTOFF_HI20, /* type */
1027 12, /* rightshift */
1028 2, /* size (0 = byte, 1 = short, 2 = long) */
1029 20, /* bitsize */
1030 FALSE, /* pc_relative */
1031 0, /* bitpos */
1032 complain_overflow_dont,/* complain_on_overflow */
1033 bfd_elf_generic_reloc, /* special_function */
1034 "R_NDS32_GOTOFF_HI20", /* name */
1035 FALSE, /* partial_inplace */
1036 0x000fffff, /* src_mask */
1037 0x000fffff, /* dst_mask */
1038 FALSE), /* pcrel_offset */
1039 HOWTO2 (R_NDS32_GOTOFF_LO12, /* type */
1040 0, /* rightshift */
1041 2, /* size (0 = byte, 1 = short, 2 = long) */
1042 12, /* bitsize */
1043 FALSE, /* pc_relative */
1044 0, /* bitpos */
1045 complain_overflow_dont,/* complain_on_overflow */
1046 bfd_elf_generic_reloc, /* special_function */
1047 "R_NDS32_GOTOFF_LO12", /* name */
1048 FALSE, /* partial_inplace */
1049 0x00000fff, /* src_mask */
1050 0x00000fff, /* dst_mask */
1051 FALSE), /* pcrel_offset */
1052
1053 /* Alignment hint for relaxable instruction. This is used with
1054 R_NDS32_LABEL as a pair. Relax this instruction from 4 bytes to 2
1055 in order to make next label aligned on word boundary. */
1056 HOWTO2 (R_NDS32_INSN16, /* type */
1057 0, /* rightshift */
1058 2, /* size (0 = byte, 1 = short, 2 = long) */
1059 32, /* bitsize */
1060 FALSE, /* pc_relative */
1061 0, /* bitpos */
1062 complain_overflow_dont,/* complain_on_overflow */
1063 nds32_elf_ignore_reloc,/* special_function */
1064 "R_NDS32_INSN16", /* name */
1065 FALSE, /* partial_inplace */
1066 0x00000fff, /* src_mask */
1067 0x00000fff, /* dst_mask */
1068 FALSE), /* pcrel_offset */
1069
1070 /* Alignment hint for label. */
1071 HOWTO2 (R_NDS32_LABEL, /* type */
1072 0, /* rightshift */
1073 2, /* size (0 = byte, 1 = short, 2 = long) */
1074 32, /* bitsize */
1075 FALSE, /* pc_relative */
1076 0, /* bitpos */
1077 complain_overflow_dont,/* complain_on_overflow */
1078 nds32_elf_ignore_reloc,/* special_function */
1079 "R_NDS32_LABEL", /* name */
1080 FALSE, /* partial_inplace */
1081 0xffffffff, /* src_mask */
1082 0xffffffff, /* dst_mask */
1083 FALSE), /* pcrel_offset */
1084
1085 /* Relax hint for unconditional call sequence */
1086 HOWTO2 (R_NDS32_LONGCALL1, /* type */
1087 0, /* rightshift */
1088 2, /* size (0 = byte, 1 = short, 2 = long) */
1089 32, /* bitsize */
1090 FALSE, /* pc_relative */
1091 0, /* bitpos */
1092 complain_overflow_dont,/* complain_on_overflow */
1093 nds32_elf_ignore_reloc,/* special_function */
1094 "R_NDS32_LONGCALL1", /* name */
1095 FALSE, /* partial_inplace */
1096 0xffffffff, /* src_mask */
1097 0xffffffff, /* dst_mask */
1098 FALSE), /* pcrel_offset */
1099
1100 /* Relax hint for conditional call sequence. */
1101 HOWTO2 (R_NDS32_LONGCALL2, /* type */
1102 0, /* rightshift */
1103 2, /* size (0 = byte, 1 = short, 2 = long) */
1104 32, /* bitsize */
1105 FALSE, /* pc_relative */
1106 0, /* bitpos */
1107 complain_overflow_dont,/* complain_on_overflow */
1108 nds32_elf_ignore_reloc,/* special_function */
1109 "R_NDS32_LONGCALL2", /* name */
1110 FALSE, /* partial_inplace */
1111 0xffffffff, /* src_mask */
1112 0xffffffff, /* dst_mask */
1113 FALSE), /* pcrel_offset */
1114
1115 /* Relax hint for conditional call sequence. */
1116 HOWTO2 (R_NDS32_LONGCALL3, /* type */
1117 0, /* rightshift */
1118 2, /* size (0 = byte, 1 = short, 2 = long) */
1119 32, /* bitsize */
1120 FALSE, /* pc_relative */
1121 0, /* bitpos */
1122 complain_overflow_dont,/* complain_on_overflow */
1123 nds32_elf_ignore_reloc,/* special_function */
1124 "R_NDS32_LONGCALL3", /* name */
1125 FALSE, /* partial_inplace */
1126 0xffffffff, /* src_mask */
1127 0xffffffff, /* dst_mask */
1128 FALSE), /* pcrel_offset */
1129
1130 /* Relax hint for unconditional branch sequence. */
1131 HOWTO2 (R_NDS32_LONGJUMP1, /* type */
1132 0, /* rightshift */
1133 2, /* size (0 = byte, 1 = short, 2 = long) */
1134 32, /* bitsize */
1135 FALSE, /* pc_relative */
1136 0, /* bitpos */
1137 complain_overflow_dont,/* complain_on_overflow */
1138 nds32_elf_ignore_reloc,/* special_function */
1139 "R_NDS32_LONGJUMP1", /* name */
1140 FALSE, /* partial_inplace */
1141 0xffffffff, /* src_mask */
1142 0xffffffff, /* dst_mask */
1143 FALSE), /* pcrel_offset */
1144
1145 /* Relax hint for conditional branch sequence. */
1146 HOWTO2 (R_NDS32_LONGJUMP2, /* type */
1147 0, /* rightshift */
1148 2, /* size (0 = byte, 1 = short, 2 = long) */
1149 32, /* bitsize */
1150 FALSE, /* pc_relative */
1151 0, /* bitpos */
1152 complain_overflow_dont,/* complain_on_overflow */
1153 nds32_elf_ignore_reloc,/* special_function */
1154 "R_NDS32_LONGJUMP2", /* name */
1155 FALSE, /* partial_inplace */
1156 0xffffffff, /* src_mask */
1157 0xffffffff, /* dst_mask */
1158 FALSE), /* pcrel_offset */
1159
1160 /* Relax hint for conditional branch sequence. */
1161 HOWTO2 (R_NDS32_LONGJUMP3, /* type */
1162 0, /* rightshift */
1163 2, /* size (0 = byte, 1 = short, 2 = long) */
1164 32, /* bitsize */
1165 FALSE, /* pc_relative */
1166 0, /* bitpos */
1167 complain_overflow_dont,/* complain_on_overflow */
1168 nds32_elf_ignore_reloc,/* special_function */
1169 "R_NDS32_LONGJUMP3", /* name */
1170 FALSE, /* partial_inplace */
1171 0xffffffff, /* src_mask */
1172 0xffffffff, /* dst_mask */
1173 FALSE), /* pcrel_offset */
1174
1175 /* Relax hint for load/store sequence. */
1176 HOWTO2 (R_NDS32_LOADSTORE, /* type */
1177 0, /* rightshift */
1178 2, /* size (0 = byte, 1 = short, 2 = long) */
1179 32, /* bitsize */
1180 FALSE, /* pc_relative */
1181 0, /* bitpos */
1182 complain_overflow_dont,/* complain_on_overflow */
1183 nds32_elf_ignore_reloc,/* special_function */
1184 "R_NDS32_LOADSTORE", /* name */
1185 FALSE, /* partial_inplace */
1186 0xffffffff, /* src_mask */
1187 0xffffffff, /* dst_mask */
1188 FALSE), /* pcrel_offset */
1189
1190 /* Relax hint for load/store sequence. */
1191 HOWTO2 (R_NDS32_9_FIXED_RELA, /* type */
1192 0, /* rightshift */
1193 1, /* size (0 = byte, 1 = short, 2 = long) */
1194 16, /* bitsize */
1195 FALSE, /* pc_relative */
1196 0, /* bitpos */
1197 complain_overflow_dont,/* complain_on_overflow */
1198 nds32_elf_ignore_reloc,/* special_function */
1199 "R_NDS32_9_FIXED_RELA",/* name */
1200 FALSE, /* partial_inplace */
1201 0x000000ff, /* src_mask */
1202 0x000000ff, /* dst_mask */
1203 FALSE), /* pcrel_offset */
1204
1205 /* Relax hint for load/store sequence. */
1206 HOWTO2 (R_NDS32_15_FIXED_RELA,/* type */
1207 0, /* rightshift */
1208 2, /* size (0 = byte, 1 = short, 2 = long) */
1209 32, /* bitsize */
1210 FALSE, /* pc_relative */
1211 0, /* bitpos */
1212 complain_overflow_dont,/* complain_on_overflow */
1213 nds32_elf_ignore_reloc,/* special_function */
1214 "R_NDS32_15_FIXED_RELA",/* name */
1215 FALSE, /* partial_inplace */
1216 0x00003fff, /* src_mask */
1217 0x00003fff, /* dst_mask */
1218 FALSE), /* pcrel_offset */
1219
1220 /* Relax hint for load/store sequence. */
1221 HOWTO2 (R_NDS32_17_FIXED_RELA,/* type */
1222 0, /* rightshift */
1223 2, /* size (0 = byte, 1 = short, 2 = long) */
1224 32, /* bitsize */
1225 FALSE, /* pc_relative */
1226 0, /* bitpos */
1227 complain_overflow_dont,/* complain_on_overflow */
1228 nds32_elf_ignore_reloc,/* special_function */
1229 "R_NDS32_17_FIXED_RELA",/* name */
1230 FALSE, /* partial_inplace */
1231 0x0000ffff, /* src_mask */
1232 0x0000ffff, /* dst_mask */
1233 FALSE), /* pcrel_offset */
1234
1235 /* Relax hint for load/store sequence. */
1236 HOWTO2 (R_NDS32_25_FIXED_RELA,/* type */
1237 0, /* rightshift */
1238 2, /* size (0 = byte, 1 = short, 2 = long) */
1239 32, /* bitsize */
1240 FALSE, /* pc_relative */
1241 0, /* bitpos */
1242 complain_overflow_dont,/* complain_on_overflow */
1243 nds32_elf_ignore_reloc,/* special_function */
1244 "R_NDS32_25_FIXED_RELA",/* name */
1245 FALSE, /* partial_inplace */
1246 0x00ffffff, /* src_mask */
1247 0x00ffffff, /* dst_mask */
1248 FALSE), /* pcrel_offset */
1249
1250 /* High 20 bits of PLT symbol offset relative to PC. */
1251 HOWTO2 (R_NDS32_PLTREL_HI20, /* type */
1252 12, /* rightshift */
1253 2, /* size (0 = byte, 1 = short, 2 = long) */
1254 20, /* bitsize */
1255 FALSE, /* pc_relative */
1256 0, /* bitpos */
1257 complain_overflow_dont,/* complain_on_overflow */
1258 bfd_elf_generic_reloc, /* special_function */
1259 "R_NDS32_PLTREL_HI20", /* name */
1260 FALSE, /* partial_inplace */
1261 0x000fffff, /* src_mask */
1262 0x000fffff, /* dst_mask */
1263 FALSE), /* pcrel_offset */
1264
1265 /* Low 12 bits of PLT symbol offset relative to PC. */
1266 HOWTO2 (R_NDS32_PLTREL_LO12, /* type */
1267 0, /* rightshift */
1268 2, /* size (0 = byte, 1 = short, 2 = long) */
1269 12, /* bitsize */
1270 FALSE, /* pc_relative */
1271 0, /* bitpos */
1272 complain_overflow_dont,/* complain_on_overflow */
1273 bfd_elf_generic_reloc, /* special_function */
1274 "R_NDS32_PLTREL_LO12", /* name */
1275 FALSE, /* partial_inplace */
1276 0x00000fff, /* src_mask */
1277 0x00000fff, /* dst_mask */
1278 FALSE), /* pcrel_offset */
1279
1280 /* High 20 bits of PLT symbol offset relative to GOT (GP). */
1281 HOWTO2 (R_NDS32_PLT_GOTREL_HI20, /* type */
1282 12, /* rightshift */
1283 2, /* size (0 = byte, 1 = short, 2 = long) */
1284 20, /* bitsize */
1285 FALSE, /* pc_relative */
1286 0, /* bitpos */
1287 complain_overflow_dont,/* complain_on_overflow */
1288 bfd_elf_generic_reloc, /* special_function */
1289 "R_NDS32_PLT_GOTREL_HI20",/* name */
1290 FALSE, /* partial_inplace */
1291 0x000fffff, /* src_mask */
1292 0x000fffff, /* dst_mask */
1293 FALSE), /* pcrel_offset */
1294
1295 /* Low 12 bits of PLT symbol offset relative to GOT (GP). */
1296 HOWTO2 (R_NDS32_PLT_GOTREL_LO12,/* type */
1297 0, /* rightshift */
1298 2, /* size (0 = byte, 1 = short, 2 = long) */
1299 12, /* bitsize */
1300 FALSE, /* pc_relative */
1301 0, /* bitpos */
1302 complain_overflow_dont,/* complain_on_overflow */
1303 bfd_elf_generic_reloc, /* special_function */
1304 "R_NDS32_PLT_GOTREL_LO12",/* name */
1305 FALSE, /* partial_inplace */
1306 0x00000fff, /* src_mask */
1307 0x00000fff, /* dst_mask */
1308 FALSE), /* pcrel_offset */
1309
1310 /* Small data area 12 bits offset. */
1311 HOWTO2 (R_NDS32_SDA12S2_DP_RELA,/* type */
1312 2, /* rightshift */
1313 2, /* size (0 = byte, 1 = short, 2 = long) */
1314 12, /* bitsize */
1315 FALSE, /* pc_relative */
1316 0, /* bitpos */
1317 complain_overflow_signed,/* complain_on_overflow */
1318 bfd_elf_generic_reloc, /* special_function */
1319 "R_NDS32_SDA12S2_DP_RELA",/* name */
1320 FALSE, /* partial_inplace */
1321 0x00000fff, /* src_mask */
1322 0x00000fff, /* dst_mask */
1323 FALSE), /* pcrel_offset */
1324
1325 /* Small data area 12 bits offset. */
1326 HOWTO2 (R_NDS32_SDA12S2_SP_RELA,/* type */
1327 2, /* rightshift */
1328 2, /* size (0 = byte, 1 = short, 2 = long) */
1329 12, /* bitsize */
1330 FALSE, /* pc_relative */
1331 0, /* bitpos */
1332 complain_overflow_signed,/* complain_on_overflow */
1333 bfd_elf_generic_reloc, /* special_function */
1334 "R_NDS32_SDA12S2_SP_RELA",/* name */
1335 FALSE, /* partial_inplace */
1336 0x00000fff, /* src_mask */
1337 0x00000fff, /* dst_mask */
1338 FALSE), /* pcrel_offset */
1339 /* Lower 12 bits of address. */
1340
1341 HOWTO2 (R_NDS32_LO12S2_DP_RELA, /* type */
1342 2, /* rightshift */
1343 2, /* size (0 = byte, 1 = short, 2 = long) */
1344 10, /* bitsize */
1345 FALSE, /* pc_relative */
1346 0, /* bitpos */
1347 complain_overflow_dont,/* complain_on_overflow */
1348 bfd_elf_generic_reloc, /* special_function */
1349 "R_NDS32_LO12S2_DP_RELA",/* name */
1350 FALSE, /* partial_inplace */
1351 0x000003ff, /* src_mask */
1352 0x000003ff, /* dst_mask */
1353 FALSE), /* pcrel_offset */
1354
1355 /* Lower 12 bits of address. */
1356 HOWTO2 (R_NDS32_LO12S2_SP_RELA,/* type */
1357 2, /* rightshift */
1358 2, /* size (0 = byte, 1 = short, 2 = long) */
1359 10, /* bitsize */
1360 FALSE, /* pc_relative */
1361 0, /* bitpos */
1362 complain_overflow_dont,/* complain_on_overflow */
1363 bfd_elf_generic_reloc, /* special_function */
1364 "R_NDS32_LO12S2_SP_RELA",/* name */
1365 FALSE, /* partial_inplace */
1366 0x000003ff, /* src_mask */
1367 0x000003ff, /* dst_mask */
1368 FALSE), /* pcrel_offset */
1369 /* Lower 12 bits of address. Special identity for or case. */
1370 HOWTO2 (R_NDS32_LO12S0_ORI_RELA,/* type */
1371 0, /* rightshift */
1372 2, /* size (0 = byte, 1 = short, 2 = long) */
1373 12, /* bitsize */
1374 FALSE, /* pc_relative */
1375 0, /* bitpos */
1376 complain_overflow_dont,/* complain_on_overflow */
1377 bfd_elf_generic_reloc, /* special_function */
1378 "R_NDS32_LO12S0_ORI_RELA",/* name */
1379 FALSE, /* partial_inplace */
1380 0x00000fff, /* src_mask */
1381 0x00000fff, /* dst_mask */
1382 FALSE), /* pcrel_offset */
1383 /* Small data area 19 bits offset. */
1384 HOWTO2 (R_NDS32_SDA16S3_RELA, /* type */
1385 3, /* rightshift */
1386 2, /* size (0 = byte, 1 = short, 2 = long) */
1387 16, /* bitsize */
1388 FALSE, /* pc_relative */
1389 0, /* bitpos */
1390 complain_overflow_signed,/* complain_on_overflow */
1391 bfd_elf_generic_reloc, /* special_function */
1392 "R_NDS32_SDA16S3_RELA",/* name */
1393 FALSE, /* partial_inplace */
1394 0x0000ffff, /* src_mask */
1395 0x0000ffff, /* dst_mask */
1396 FALSE), /* pcrel_offset */
1397
1398 /* Small data area 15 bits offset. */
1399 HOWTO2 (R_NDS32_SDA17S2_RELA, /* type */
1400 2, /* rightshift */
1401 2, /* size (0 = byte, 1 = short, 2 = long) */
1402 17, /* bitsize */
1403 FALSE, /* pc_relative */
1404 0, /* bitpos */
1405 complain_overflow_signed,/* complain_on_overflow */
1406 bfd_elf_generic_reloc, /* special_function */
1407 "R_NDS32_SDA17S2_RELA",/* name */
1408 FALSE, /* partial_inplace */
1409 0x0001ffff, /* src_mask */
1410 0x0001ffff, /* dst_mask */
1411 FALSE), /* pcrel_offset */
1412
1413 HOWTO2 (R_NDS32_SDA18S1_RELA, /* type */
1414 1, /* rightshift */
1415 2, /* size (0 = byte, 1 = short, 2 = long) */
1416 18, /* bitsize */
1417 FALSE, /* pc_relative */
1418 0, /* bitpos */
1419 complain_overflow_signed,/* complain_on_overflow */
1420 bfd_elf_generic_reloc, /* special_function */
1421 "R_NDS32_SDA18S1_RELA",/* name */
1422 FALSE, /* partial_inplace */
1423 0x0003ffff, /* src_mask */
1424 0x0003ffff, /* dst_mask */
1425 FALSE), /* pcrel_offset */
1426
1427 HOWTO2 (R_NDS32_SDA19S0_RELA, /* type */
1428 0, /* rightshift */
1429 2, /* size (0 = byte, 1 = short, 2 = long) */
1430 19, /* bitsize */
1431 FALSE, /* pc_relative */
1432 0, /* bitpos */
1433 complain_overflow_signed,/* complain_on_overflow */
1434 bfd_elf_generic_reloc, /* special_function */
1435 "R_NDS32_SDA19S0_RELA",/* name */
1436 FALSE, /* partial_inplace */
1437 0x0007ffff, /* src_mask */
1438 0x0007ffff, /* dst_mask */
1439 FALSE), /* pcrel_offset */
1440 HOWTO2 (R_NDS32_DWARF2_OP1_RELA,/* type */
1441 0, /* rightshift */
1442 0, /* size (0 = byte, 1 = short, 2 = long) */
1443 8, /* bitsize */
1444 FALSE, /* pc_relative */
1445 0, /* bitpos */
1446 complain_overflow_dont,/* complain_on_overflow */
1447 nds32_elf_ignore_reloc,/* special_function */
1448 "R_NDS32_DWARF2_OP1_RELA",/* name */
1449 FALSE, /* partial_inplace */
1450 0xff, /* src_mask */
1451 0xff, /* dst_mask */
1452 FALSE), /* pcrel_offset */
1453 HOWTO2 (R_NDS32_DWARF2_OP2_RELA,/* type */
1454 0, /* rightshift */
1455 1, /* size (0 = byte, 1 = short, 2 = long) */
1456 16, /* bitsize */
1457 FALSE, /* pc_relative */
1458 0, /* bitpos */
1459 complain_overflow_dont,/* complain_on_overflow */
1460 nds32_elf_ignore_reloc,/* special_function */
1461 "R_NDS32_DWARF2_OP2_RELA",/* name */
1462 FALSE, /* partial_inplace */
1463 0xffff, /* src_mask */
1464 0xffff, /* dst_mask */
1465 FALSE), /* pcrel_offset */
1466 HOWTO2 (R_NDS32_DWARF2_LEB_RELA,/* type */
1467 0, /* rightshift */
1468 2, /* size (0 = byte, 1 = short, 2 = long) */
1469 32, /* bitsize */
1470 FALSE, /* pc_relative */
1471 0, /* bitpos */
1472 complain_overflow_dont,/* complain_on_overflow */
1473 nds32_elf_ignore_reloc,/* special_function */
1474 "R_NDS32_DWARF2_LEB_RELA",/* name */
1475 FALSE, /* partial_inplace */
1476 0xffffffff, /* src_mask */
1477 0xffffffff, /* dst_mask */
1478 FALSE), /* pcrel_offset */
1479 HOWTO2 (R_NDS32_UPDATE_TA_RELA,/* type */
1480 0, /* rightshift */
1481 1, /* size (0 = byte, 1 = short, 2 = long) */
1482 16, /* bitsize */
1483 FALSE, /* pc_relative */
1484 0, /* bitpos */
1485 complain_overflow_dont,/* complain_on_overflow */
1486 nds32_elf_ignore_reloc,/* special_function */
1487 "R_NDS32_UPDATE_TA_RELA",/* name */
1488 FALSE, /* partial_inplace */
1489 0xffff, /* src_mask */
1490 0xffff, /* dst_mask */
1491 FALSE), /* pcrel_offset */
1492 /* Like R_NDS32_PCREL, but referring to the procedure linkage table
1493 entry for the symbol. */
1494 HOWTO2 (R_NDS32_9_PLTREL, /* type */
1495 1, /* rightshift */
1496 1, /* size (0 = byte, 1 = short, 2 = long) */
1497 8, /* bitsize */
1498 TRUE, /* pc_relative */
1499 0, /* bitpos */
1500 complain_overflow_signed,/* complain_on_overflow */
1501 bfd_elf_generic_reloc, /* special_function */
1502 "R_NDS32_9_PLTREL", /* name */
1503 FALSE, /* partial_inplace */
1504 0xff, /* src_mask */
1505 0xff, /* dst_mask */
1506 TRUE), /* pcrel_offset */
1507 /* Low 20 bits of PLT symbol offset relative to GOT (GP). */
1508 HOWTO2 (R_NDS32_PLT_GOTREL_LO20,/* type */
1509 0, /* rightshift */
1510 2, /* size (0 = byte, 1 = short, 2 = long) */
1511 20, /* bitsize */
1512 FALSE, /* pc_relative */
1513 0, /* bitpos */
1514 complain_overflow_dont,/* complain_on_overflow */
1515 bfd_elf_generic_reloc, /* special_function */
1516 "R_NDS32_PLT_GOTREL_LO20",/* name */
1517 FALSE, /* partial_inplace */
1518 0x000fffff, /* src_mask */
1519 0x000fffff, /* dst_mask */
1520 FALSE), /* pcrel_offset */
1521 /* low 15 bits of PLT symbol offset relative to GOT (GP) */
1522 HOWTO2 (R_NDS32_PLT_GOTREL_LO15,/* type */
1523 0, /* rightshift */
1524 2, /* size (0 = byte, 1 = short, 2 = long) */
1525 15, /* bitsize */
1526 FALSE, /* pc_relative */
1527 0, /* bitpos */
1528 complain_overflow_dont,/* complain_on_overflow */
1529 bfd_elf_generic_reloc, /* special_function */
1530 "R_NDS32_PLT_GOTREL_LO15",/* name */
1531 FALSE, /* partial_inplace */
1532 0x00007fff, /* src_mask */
1533 0x00007fff, /* dst_mask */
1534 FALSE), /* pcrel_offset */
1535 /* Low 19 bits of PLT symbol offset relative to GOT (GP). */
1536 HOWTO2 (R_NDS32_PLT_GOTREL_LO19,/* type */
1537 0, /* rightshift */
1538 2, /* size (0 = byte, 1 = short, 2 = long) */
1539 19, /* bitsize */
1540 FALSE, /* pc_relative */
1541 0, /* bitpos */
1542 complain_overflow_dont,/* complain_on_overflow */
1543 bfd_elf_generic_reloc, /* special_function */
1544 "R_NDS32_PLT_GOTREL_LO19",/* name */
1545 FALSE, /* partial_inplace */
1546 0x0007ffff, /* src_mask */
1547 0x0007ffff, /* dst_mask */
1548 FALSE), /* pcrel_offset */
1549 HOWTO2 (R_NDS32_GOT_LO15, /* type */
1550 0, /* rightshift */
1551 2, /* size (0 = byte, 1 = short, 2 = long) */
1552 15, /* bitsize */
1553 FALSE, /* pc_relative */
1554 0, /* bitpos */
1555 complain_overflow_dont,/* complain_on_overflow */
1556 bfd_elf_generic_reloc, /* special_function */
1557 "R_NDS32_GOT_LO15", /* name */
1558 FALSE, /* partial_inplace */
1559 0x00007fff, /* src_mask */
1560 0x00007fff, /* dst_mask */
1561 FALSE), /* pcrel_offset */
1562 HOWTO2 (R_NDS32_GOT_LO19, /* type */
1563 0, /* rightshift */
1564 2, /* size (0 = byte, 1 = short, 2 = long) */
1565 19, /* bitsize */
1566 FALSE, /* pc_relative */
1567 0, /* bitpos */
1568 complain_overflow_dont,/* complain_on_overflow */
1569 bfd_elf_generic_reloc, /* special_function */
1570 "R_NDS32_GOT_LO19", /* name */
1571 FALSE, /* partial_inplace */
1572 0x0007ffff, /* src_mask */
1573 0x0007ffff, /* dst_mask */
1574 FALSE), /* pcrel_offset */
1575 HOWTO2 (R_NDS32_GOTOFF_LO15, /* type */
1576 0, /* rightshift */
1577 2, /* size (0 = byte, 1 = short, 2 = long) */
1578 15, /* bitsize */
1579 FALSE, /* pc_relative */
1580 0, /* bitpos */
1581 complain_overflow_dont,/* complain_on_overflow */
1582 bfd_elf_generic_reloc, /* special_function */
1583 "R_NDS32_GOTOFF_LO15", /* name */
1584 FALSE, /* partial_inplace */
1585 0x00007fff, /* src_mask */
1586 0x00007fff, /* dst_mask */
1587 FALSE), /* pcrel_offset */
1588 HOWTO2 (R_NDS32_GOTOFF_LO19, /* type */
1589 0, /* rightshift */
1590 2, /* size (0 = byte, 1 = short, 2 = long) */
1591 19, /* bitsize */
1592 FALSE, /* pc_relative */
1593 0, /* bitpos */
1594 complain_overflow_dont,/* complain_on_overflow */
1595 bfd_elf_generic_reloc, /* special_function */
1596 "R_NDS32_GOTOFF_LO19", /* name */
1597 FALSE, /* partial_inplace */
1598 0x0007ffff, /* src_mask */
1599 0x0007ffff, /* dst_mask */
1600 FALSE), /* pcrel_offset */
1601 /* GOT 15 bits offset. */
1602 HOWTO2 (R_NDS32_GOT15S2_RELA, /* type */
1603 2, /* rightshift */
1604 2, /* size (0 = byte, 1 = short, 2 = long) */
1605 15, /* bitsize */
1606 FALSE, /* pc_relative */
1607 0, /* bitpos */
1608 complain_overflow_signed,/* complain_on_overflow */
1609 bfd_elf_generic_reloc, /* special_function */
1610 "R_NDS32_GOT15S2_RELA",/* name */
1611 FALSE, /* partial_inplace */
1612 0x00007fff, /* src_mask */
1613 0x00007fff, /* dst_mask */
1614 FALSE), /* pcrel_offset */
1615 /* GOT 17 bits offset. */
1616 HOWTO2 (R_NDS32_GOT17S2_RELA, /* type */
1617 2, /* rightshift */
1618 2, /* size (0 = byte, 1 = short, 2 = long) */
1619 17, /* bitsize */
1620 FALSE, /* pc_relative */
1621 0, /* bitpos */
1622 complain_overflow_signed,/* complain_on_overflow */
1623 bfd_elf_generic_reloc, /* special_function */
1624 "R_NDS32_GOT17S2_RELA",/* name */
1625 FALSE, /* partial_inplace */
1626 0x0001ffff, /* src_mask */
1627 0x0001ffff, /* dst_mask */
1628 FALSE), /* pcrel_offset */
1629 /* A 5 bit address. */
1630 HOWTO2 (R_NDS32_5_RELA, /* type */
1631 0, /* rightshift */
1632 1, /* size (0 = byte, 1 = short, 2 = long) */
1633 5, /* bitsize */
1634 FALSE, /* pc_relative */
1635 0, /* bitpos */
1636 complain_overflow_signed,/* complain_on_overflow */
1637 bfd_elf_generic_reloc, /* special_function */
1638 "R_NDS32_5_RELA", /* name */
1639 FALSE, /* partial_inplace */
1640 0x1f, /* src_mask */
1641 0x1f, /* dst_mask */
1642 FALSE), /* pcrel_offset */
1643 HOWTO2 (R_NDS32_10_UPCREL_RELA,/* type */
1644 1, /* rightshift */
1645 1, /* size (0 = byte, 1 = short, 2 = long) */
1646 9, /* bitsize */
1647 TRUE, /* pc_relative */
1648 0, /* bitpos */
1649 complain_overflow_unsigned,/* complain_on_overflow */
1650 bfd_elf_generic_reloc, /* special_function */
1651 "R_NDS32_10_UPCREL_RELA",/* name */
1652 FALSE, /* partial_inplace */
1653 0x1ff, /* src_mask */
1654 0x1ff, /* dst_mask */
1655 TRUE), /* pcrel_offset */
1656 HOWTO2 (R_NDS32_SDA_FP7U2_RELA,/* type */
1657 2, /* rightshift */
1658 1, /* size (0 = byte, 1 = short, 2 = long) */
1659 7, /* bitsize */
1660 FALSE, /* pc_relative */
1661 0, /* bitpos */
1662 complain_overflow_unsigned,/* complain_on_overflow */
1663 bfd_elf_generic_reloc, /* special_function */
1664 "R_NDS32_SDA_FP7U2_RELA",/* name */
1665 FALSE, /* partial_inplace */
1666 0x0000007f, /* src_mask */
1667 0x0000007f, /* dst_mask */
1668 FALSE), /* pcrel_offset */
1669 HOWTO2 (R_NDS32_WORD_9_PCREL_RELA,/* type */
1670 1, /* rightshift */
1671 2, /* size (0 = byte, 1 = short, 2 = long) */
1672 8, /* bitsize */
1673 TRUE, /* pc_relative */
1674 0, /* bitpos */
1675 complain_overflow_signed,/* complain_on_overflow */
1676 bfd_elf_generic_reloc, /* special_function */
1677 "R_NDS32_WORD_9_PCREL_RELA",/* name */
1678 FALSE, /* partial_inplace */
1679 0xff, /* src_mask */
1680 0xff, /* dst_mask */
1681 TRUE), /* pcrel_offset */
1682 HOWTO2 (R_NDS32_25_ABS_RELA, /* type */
1683 1, /* rightshift */
1684 2, /* size (0 = byte, 1 = short, 2 = long) */
1685 24, /* bitsize */
1686 FALSE, /* pc_relative */
1687 0, /* bitpos */
1688 complain_overflow_dont,/* complain_on_overflow */
1689 bfd_elf_generic_reloc, /* special_function */
1690 "R_NDS32_25_ABS_RELA", /* name */
1691 FALSE, /* partial_inplace */
1692 0xffffff, /* src_mask */
1693 0xffffff, /* dst_mask */
1694 FALSE), /* pcrel_offset */
1695
1696 /* A relative 17 bit relocation for ifc, right shifted by 1. */
1697 HOWTO2 (R_NDS32_17IFC_PCREL_RELA,/* type */
1698 1, /* rightshift */
1699 2, /* size (0 = byte, 1 = short, 2 = long) */
1700 16, /* bitsize */
1701 TRUE, /* pc_relative */
1702 0, /* bitpos */
1703 complain_overflow_signed,/* complain_on_overflow */
1704 bfd_elf_generic_reloc, /* special_function */
1705 "R_NDS32_17IFC_PCREL_RELA",/* name */
1706 FALSE, /* partial_inplace */
1707 0xffff, /* src_mask */
1708 0xffff, /* dst_mask */
1709 TRUE), /* pcrel_offset */
1710
1711 /* A relative unsigned 10 bit relocation for ifc, right shifted by 1. */
1712 HOWTO2 (R_NDS32_10IFCU_PCREL_RELA,/* type */
1713 1, /* rightshift */
1714 1, /* size (0 = byte, 1 = short, 2 = long) */
1715 9, /* bitsize */
1716 TRUE, /* pc_relative */
1717 0, /* bitpos */
1718 complain_overflow_unsigned,/* complain_on_overflow */
1719 bfd_elf_generic_reloc, /* special_function */
1720 "R_NDS32_10IFCU_PCREL_RELA",/* name */
1721 FALSE, /* partial_inplace */
1722 0x1ff, /* src_mask */
1723 0x1ff, /* dst_mask */
1724 TRUE), /* pcrel_offset */
1725
1726 /* Like R_NDS32_HI20, but referring to the TLS LE entry for the symbol. */
1727 HOWTO2 (R_NDS32_TLS_LE_HI20, /* type */
1728 12, /* rightshift */
1729 2, /* size (0 = byte, 1 = short, 2 = long) */
1730 20, /* bitsize */
1731 FALSE, /* pc_relative */
1732 0, /* bitpos */
1733 complain_overflow_dont,/* complain_on_overflow */
1734 bfd_elf_generic_reloc, /* special_function */
1735 "R_NDS32_TLS_LE_HI20", /* name */
1736 FALSE, /* partial_inplace */
1737 0x000fffff, /* src_mask */
1738 0x000fffff, /* dst_mask */
1739 FALSE), /* pcrel_offset */
1740
1741 HOWTO2 (R_NDS32_TLS_LE_LO12, /* type */
1742 0, /* rightshift */
1743 2, /* size (0 = byte, 1 = short, 2 = long) */
1744 12, /* bitsize */
1745 FALSE, /* pc_relative */
1746 0, /* bitpos */
1747 complain_overflow_dont,/* complain_on_overflow */
1748 bfd_elf_generic_reloc, /* special_function */
1749 "R_NDS32_TLS_LE_LO12", /* name */
1750 FALSE, /* partial_inplace */
1751 0x00000fff, /* src_mask */
1752 0x00000fff, /* dst_mask */
1753 FALSE), /* pcrel_offset */
1754
1755 /* Like R_NDS32_HI20, but referring to the TLS IE entry for the symbol. */
1756 HOWTO2 (R_NDS32_TLS_IE_HI20, /* type */
1757 12, /* rightshift */
1758 2, /* size (0 = byte, 1 = short, 2 = long) */
1759 20, /* bitsize */
1760 FALSE, /* pc_relative */
1761 0, /* bitpos */
1762 complain_overflow_dont,/* complain_on_overflow */
1763 bfd_elf_generic_reloc, /* special_function */
1764 "R_NDS32_TLS_IE_HI20", /* name */
1765 FALSE, /* partial_inplace */
1766 0x000fffff, /* src_mask */
1767 0x000fffff, /* dst_mask */
1768 FALSE), /* pcrel_offset */
1769
1770 HOWTO2 (R_NDS32_TLS_IE_LO12S2,/* type */
1771 2, /* rightshift */
1772 2, /* size (0 = byte, 1 = short, 2 = long) */
1773 10, /* bitsize */
1774 FALSE, /* pc_relative */
1775 0, /* bitpos */
1776 complain_overflow_dont,/* complain_on_overflow */
1777 bfd_elf_generic_reloc, /* special_function */
1778 "R_NDS32_TLS_IE_LO12S2",/* name */
1779 FALSE, /* partial_inplace */
1780 0x000003ff, /* src_mask */
1781 0x000003ff, /* dst_mask */
1782 FALSE), /* pcrel_offset */
1783
1784 /* TLS LE TP offset relocation */
1785 HOWTO2 (R_NDS32_TLS_TPOFF, /* type */
1786 0, /* rightshift */
1787 2, /* size (0 = byte, 1 = short, 2 = long) */
1788 32, /* bitsize */
1789 FALSE, /* pc_relative */
1790 0, /* bitpos */
1791 complain_overflow_bitfield,/* complain_on_overflow */
1792 bfd_elf_generic_reloc, /* special_function */
1793 "R_NDS32_TLS_TPOFF", /* name */
1794 FALSE, /* partial_inplace */
1795 0xffffffff, /* src_mask */
1796 0xffffffff, /* dst_mask */
1797 FALSE), /* pcrel_offset */
1798
1799 /* A 20 bit address. */
1800 HOWTO2 (R_NDS32_TLS_LE_20, /* type */
1801 0, /* rightshift */
1802 2, /* size (0 = byte, 1 = short, 2 = long) */
1803 20, /* bitsize */
1804 FALSE, /* pc_relative */
1805 0, /* bitpos */
1806 complain_overflow_signed,/* complain_on_overflow */
1807 bfd_elf_generic_reloc, /* special_function */
1808 "R_NDS32_TLS_LE_20", /* name */
1809 FALSE, /* partial_inplace */
1810 0xfffff, /* src_mask */
1811 0xfffff, /* dst_mask */
1812 FALSE), /* pcrel_offset */
1813
1814 HOWTO2 (R_NDS32_TLS_LE_15S0, /* type */
1815 0, /* rightshift */
1816 2, /* size (0 = byte, 1 = short, 2 = long) */
1817 15, /* bitsize */
1818 FALSE, /* pc_relative */
1819 0, /* bitpos */
1820 complain_overflow_signed,/* complain_on_overflow */
1821 bfd_elf_generic_reloc, /* special_function */
1822 "R_NDS32_TLS_LE_15S0", /* name */
1823 FALSE, /* partial_inplace */
1824 0x7fff, /* src_mask */
1825 0x7fff, /* dst_mask */
1826 FALSE), /* pcrel_offset */
1827 HOWTO2 (R_NDS32_TLS_LE_15S1, /* type */
1828 1, /* rightshift */
1829 2, /* size (0 = byte, 1 = short, 2 = long) */
1830 15, /* bitsize */
1831 FALSE, /* pc_relative */
1832 0, /* bitpos */
1833 complain_overflow_signed,/* complain_on_overflow */
1834 bfd_elf_generic_reloc, /* special_function */
1835 "R_NDS32_TLS_LE_15S1", /* name */
1836 FALSE, /* partial_inplace */
1837 0x7fff, /* src_mask */
1838 0x7fff, /* dst_mask */
1839 FALSE), /* pcrel_offset */
1840 HOWTO2 (R_NDS32_TLS_LE_15S2, /* type */
1841 2, /* rightshift */
1842 2, /* size (0 = byte, 1 = short, 2 = long) */
1843 15, /* bitsize */
1844 FALSE, /* pc_relative */
1845 0, /* bitpos */
1846 complain_overflow_signed,/* complain_on_overflow */
1847 bfd_elf_generic_reloc, /* special_function */
1848 "R_NDS32_TLS_LE_15S2", /* name */
1849 FALSE, /* partial_inplace */
1850 0x7fff, /* src_mask */
1851 0x7fff, /* dst_mask */
1852 FALSE), /* pcrel_offset */
1853
1854 /* Relax hint for unconditional call sequence */
1855 HOWTO2 (R_NDS32_LONGCALL4, /* type */
1856 0, /* rightshift */
1857 2, /* size (0 = byte, 1 = short, 2 = long) */
1858 32, /* bitsize */
1859 FALSE, /* pc_relative */
1860 0, /* bitpos */
1861 complain_overflow_dont,/* complain_on_overflow */
1862 nds32_elf_ignore_reloc,/* special_function */
1863 "R_NDS32_LONGCALL4", /* name */
1864 FALSE, /* partial_inplace */
1865 0xffffffff, /* src_mask */
1866 0xffffffff, /* dst_mask */
1867 FALSE), /* pcrel_offset */
1868
1869 /* Relax hint for conditional call sequence. */
1870 HOWTO2 (R_NDS32_LONGCALL5, /* type */
1871 0, /* rightshift */
1872 2, /* size (0 = byte, 1 = short, 2 = long) */
1873 32, /* bitsize */
1874 FALSE, /* pc_relative */
1875 0, /* bitpos */
1876 complain_overflow_dont,/* complain_on_overflow */
1877 nds32_elf_ignore_reloc,/* special_function */
1878 "R_NDS32_LONGCALL5", /* name */
1879 FALSE, /* partial_inplace */
1880 0xffffffff, /* src_mask */
1881 0xffffffff, /* dst_mask */
1882 FALSE), /* pcrel_offset */
1883
1884 /* Relax hint for conditional call sequence. */
1885 HOWTO2 (R_NDS32_LONGCALL6, /* type */
1886 0, /* rightshift */
1887 2, /* size (0 = byte, 1 = short, 2 = long) */
1888 32, /* bitsize */
1889 FALSE, /* pc_relative */
1890 0, /* bitpos */
1891 complain_overflow_dont,/* complain_on_overflow */
1892 nds32_elf_ignore_reloc,/* special_function */
1893 "R_NDS32_LONGCALL6", /* name */
1894 FALSE, /* partial_inplace */
1895 0xffffffff, /* src_mask */
1896 0xffffffff, /* dst_mask */
1897 FALSE), /* pcrel_offset */
1898
1899 /* Relax hint for unconditional branch sequence. */
1900 HOWTO2 (R_NDS32_LONGJUMP4, /* type */
1901 0, /* rightshift */
1902 2, /* size (0 = byte, 1 = short, 2 = long) */
1903 32, /* bitsize */
1904 FALSE, /* pc_relative */
1905 0, /* bitpos */
1906 complain_overflow_dont,/* complain_on_overflow */
1907 nds32_elf_ignore_reloc,/* special_function */
1908 "R_NDS32_LONGJUMP4", /* name */
1909 FALSE, /* partial_inplace */
1910 0xffffffff, /* src_mask */
1911 0xffffffff, /* dst_mask */
1912 FALSE), /* pcrel_offset */
1913
1914 /* Relax hint for conditional branch sequence. */
1915 HOWTO2 (R_NDS32_LONGJUMP5, /* type */
1916 0, /* rightshift */
1917 2, /* size (0 = byte, 1 = short, 2 = long) */
1918 32, /* bitsize */
1919 FALSE, /* pc_relative */
1920 0, /* bitpos */
1921 complain_overflow_dont,/* complain_on_overflow */
1922 nds32_elf_ignore_reloc,/* special_function */
1923 "R_NDS32_LONGJUMP5", /* name */
1924 FALSE, /* partial_inplace */
1925 0xffffffff, /* src_mask */
1926 0xffffffff, /* dst_mask */
1927 FALSE), /* pcrel_offset */
1928
1929 /* Relax hint for conditional branch sequence. */
1930 HOWTO2 (R_NDS32_LONGJUMP6, /* type */
1931 0, /* rightshift */
1932 2, /* size (0 = byte, 1 = short, 2 = long) */
1933 32, /* bitsize */
1934 FALSE, /* pc_relative */
1935 0, /* bitpos */
1936 complain_overflow_dont,/* complain_on_overflow */
1937 nds32_elf_ignore_reloc,/* special_function */
1938 "R_NDS32_LONGJUMP6", /* name */
1939 FALSE, /* partial_inplace */
1940 0xffffffff, /* src_mask */
1941 0xffffffff, /* dst_mask */
1942 FALSE), /* pcrel_offset */
1943
1944 /* Relax hint for conditional branch sequence. */
1945 HOWTO2 (R_NDS32_LONGJUMP7, /* type */
1946 0, /* rightshift */
1947 2, /* size (0 = byte, 1 = short, 2 = long) */
1948 32, /* bitsize */
1949 FALSE, /* pc_relative */
1950 0, /* bitpos */
1951 complain_overflow_dont,/* complain_on_overflow */
1952 nds32_elf_ignore_reloc,/* special_function */
1953 "R_NDS32_LONGJUMP7", /* name */
1954 FALSE, /* partial_inplace */
1955 0xffffffff, /* src_mask */
1956 0xffffffff, /* dst_mask */
1957 FALSE), /* pcrel_offset */
1958
1959 HOWTO2 (R_NDS32_TLS_IE_LO12, /* type */
1960 0, /* rightshift */
1961 2, /* size (0 = byte, 1 = short, 2 = long) */
1962 12, /* bitsize */
1963 FALSE, /* pc_relative */
1964 0, /* bitpos */
1965 complain_overflow_dont,/* complain_on_overflow */
1966 bfd_elf_generic_reloc, /* special_function */
1967 "R_NDS32_TLS_IE_LO12", /* name */
1968 FALSE, /* partial_inplace */
1969 0x00000fff, /* src_mask */
1970 0x00000fff, /* dst_mask */
1971 FALSE), /* pcrel_offset */
1972
1973 /* Like R_NDS32_HI20, but referring to the TLS IE (PIE)
1974 entry for the symbol. */
1975 HOWTO2 (R_NDS32_TLS_IEGP_HI20,/* type */
1976 12, /* rightshift */
1977 2, /* size (0 = byte, 1 = short, 2 = long) */
1978 20, /* bitsize */
1979 FALSE, /* pc_relative */
1980 0, /* bitpos */
1981 complain_overflow_dont,/* complain_on_overflow */
1982 bfd_elf_generic_reloc, /* special_function */
1983 "R_NDS32_TLS_IEGP_HI20",/* name */
1984 FALSE, /* partial_inplace */
1985 0x000fffff, /* src_mask */
1986 0x000fffff, /* dst_mask */
1987 FALSE), /* pcrel_offset */
1988
1989 HOWTO2 (R_NDS32_TLS_IEGP_LO12,/* type */
1990 0, /* rightshift */
1991 2, /* size (0 = byte, 1 = short, 2 = long) */
1992 12, /* bitsize */
1993 FALSE, /* pc_relative */
1994 0, /* bitpos */
1995 complain_overflow_dont,/* complain_on_overflow */
1996 bfd_elf_generic_reloc, /* special_function */
1997 "R_NDS32_TLS_IEGP_LO12",/* name */
1998 FALSE, /* partial_inplace */
1999 0x00000fff, /* src_mask */
2000 0x00000fff, /* dst_mask */
2001 FALSE), /* pcrel_offset */
2002
2003 HOWTO2 (R_NDS32_TLS_IEGP_LO12S2,/* type */
2004 2, /* rightshift */
2005 2, /* size (0 = byte, 1 = short, 2 = long) */
2006 10, /* bitsize */
2007 FALSE, /* pc_relative */
2008 0, /* bitpos */
2009 complain_overflow_dont,/* complain_on_overflow */
2010 bfd_elf_generic_reloc, /* special_function */
2011 "R_NDS32_TLS_IEGP_LO12S2",/* name */
2012 FALSE, /* partial_inplace */
2013 0x000003ff, /* src_mask */
2014 0x000003ff, /* dst_mask */
2015 FALSE), /* pcrel_offset */
2016
2017 /* TLS description relocation */
2018 HOWTO2 (R_NDS32_TLS_DESC, /* type */
2019 12, /* rightshift */
2020 2, /* size (0 = byte, 1 = short, 2 = long) */
2021 20, /* bitsize */
2022 FALSE, /* pc_relative */
2023 0, /* bitpos */
2024 complain_overflow_dont,/* complain_on_overflow */
2025 nds32_elf_hi20_reloc, /* special_function */
2026 "R_NDS32_TLS_DESC_HI20",/* name */
2027 FALSE, /* partial_inplace */
2028 0x000fffff, /* src_mask */
2029 0x000fffff, /* dst_mask */
2030 FALSE), /* pcrel_offset */
2031
2032 /* TLS GD/LD description offset high part. */
2033 HOWTO2 (R_NDS32_TLS_DESC_HI20,/* type */
2034 12, /* rightshift */
2035 2, /* size (0 = byte, 1 = short, 2 = long) */
2036 20, /* bitsize */
2037 FALSE, /* pc_relative */
2038 0, /* bitpos */
2039 complain_overflow_dont,/* complain_on_overflow */
2040 nds32_elf_hi20_reloc, /* special_function */
2041 "R_NDS32_TLS_DESC_HI20",/* name */
2042 FALSE, /* partial_inplace */
2043 0x000fffff, /* src_mask */
2044 0x000fffff, /* dst_mask */
2045 FALSE), /* pcrel_offset */
2046
2047 /* TLS GD/LD description offset low part. */
2048 HOWTO2 (R_NDS32_TLS_DESC_LO12,/* type */
2049 0, /* rightshift */
2050 2, /* size (0 = byte, 1 = short, 2 = long) */
2051 12, /* bitsize */
2052 FALSE, /* pc_relative */
2053 0, /* bitpos */
2054 complain_overflow_dont,/* complain_on_overflow */
2055 nds32_elf_lo12_reloc, /* special_function */
2056 "R_NDS32_TLS_DESC_LO12",/* name */
2057 FALSE, /* partial_inplace */
2058 0x00000fff, /* src_mask */
2059 0x00000fff, /* dst_mask */
2060 FALSE), /* pcrel_offset */
2061
2062 /* TLS GD/LD description offset set (movi). */
2063 HOWTO2 (R_NDS32_TLS_DESC_20, /* type */
2064 0, /* rightshift */
2065 2, /* size (0 = byte, 1 = short, 2 = long) */
2066 20, /* bitsize */
2067 FALSE, /* pc_relative */
2068 0, /* bitpos */
2069 complain_overflow_signed,/* complain_on_overflow */
2070 bfd_elf_generic_reloc, /* special_function */
2071 "R_NDS32_TLS_DESC_20", /* name */
2072 FALSE, /* partial_inplace */
2073 0x000fffff, /* src_mask */
2074 0x000fffff, /* dst_mask */
2075 FALSE), /* pcrel_offset */
2076
2077 /* TLS GD/LD description offset set (lwi.gp). */
2078 HOWTO2 (R_NDS32_TLS_DESC_SDA17S2,/* type */
2079 2, /* rightshift */
2080 2, /* size (0 = byte, 1 = short, 2 = long) */
2081 17, /* bitsize */
2082 FALSE, /* pc_relative */
2083 0, /* bitpos */
2084 complain_overflow_signed,/* complain_on_overflow */
2085 bfd_elf_generic_reloc, /* special_function */
2086 "R_NDS32_TLS_DESC_SDA17S2",/* name */
2087 FALSE, /* partial_inplace */
2088 0x0001ffff, /* src_mask */
2089 0x0001ffff, /* dst_mask */
2090 FALSE), /* pcrel_offset */
2091 };
2092
2093 /* Relocations used for relaxation. */
2094 #define HOWTO3(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
2095 [C-R_NDS32_RELAX_ENTRY] = HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC)
2096
2097 static reloc_howto_type nds32_elf_relax_howto_table[] = {
2098 HOWTO3 (R_NDS32_RELAX_ENTRY, /* type */
2099 0, /* rightshift */
2100 2, /* size (0 = byte, 1 = short, 2 = long) */
2101 32, /* bitsize */
2102 FALSE, /* pc_relative */
2103 0, /* bitpos */
2104 complain_overflow_dont,/* complain_on_overflow */
2105 nds32_elf_ignore_reloc,/* special_function */
2106 "R_NDS32_RELAX_ENTRY", /* name */
2107 FALSE, /* partial_inplace */
2108 0xffffffff, /* src_mask */
2109 0xffffffff, /* dst_mask */
2110 FALSE), /* pcrel_offset */
2111 HOWTO3 (R_NDS32_GOT_SUFF, /* type */
2112 0, /* rightshift */
2113 2, /* size (0 = byte, 1 = short, 2 = long) */
2114 32, /* bitsize */
2115 FALSE, /* pc_relative */
2116 0, /* bitpos */
2117 complain_overflow_dont,/* complain_on_overflow */
2118 nds32_elf_ignore_reloc,/* special_function */
2119 "R_NDS32_GOT_SUFF", /* name */
2120 FALSE, /* partial_inplace */
2121 0xffffffff, /* src_mask */
2122 0xffffffff, /* dst_mask */
2123 FALSE), /* pcrel_offset */
2124 HOWTO3 (R_NDS32_GOTOFF_SUFF, /* type */
2125 0, /* rightshift */
2126 2, /* size (0 = byte, 1 = short, 2 = long) */
2127 32, /* bitsize */
2128 FALSE, /* pc_relative */
2129 0, /* bitpos */
2130 complain_overflow_bitfield,/* complain_on_overflow */
2131 nds32_elf_ignore_reloc,/* special_function */
2132 "R_NDS32_GOTOFF_SUFF", /* name */
2133 FALSE, /* partial_inplace */
2134 0xffffffff, /* src_mask */
2135 0xffffffff, /* dst_mask */
2136 FALSE), /* pcrel_offset */
2137 HOWTO3 (R_NDS32_PLT_GOT_SUFF, /* type */
2138 0, /* rightshift */
2139 2, /* size (0 = byte, 1 = short, 2 = long) */
2140 32, /* bitsize */
2141 FALSE, /* pc_relative */
2142 0, /* bitpos */
2143 complain_overflow_dont,/* complain_on_overflow */
2144 nds32_elf_ignore_reloc,/* special_function */
2145 "R_NDS32_PLT_GOT_SUFF",/* name */
2146 FALSE, /* partial_inplace */
2147 0xffffffff, /* src_mask */
2148 0xffffffff, /* dst_mask */
2149 FALSE), /* pcrel_offset */
2150 HOWTO3 (R_NDS32_MULCALL_SUFF, /* type */
2151 0, /* rightshift */
2152 2, /* size (0 = byte, 1 = short, 2 = long) */
2153 32, /* bitsize */
2154 FALSE, /* pc_relative */
2155 0, /* bitpos */
2156 complain_overflow_dont,/* complain_on_overflow */
2157 nds32_elf_ignore_reloc,/* special_function */
2158 "R_NDS32_MULCALL_SUFF",/* name */
2159 FALSE, /* partial_inplace */
2160 0xffffffff, /* src_mask */
2161 0xffffffff, /* dst_mask */
2162 FALSE), /* pcrel_offset */
2163 HOWTO3 (R_NDS32_PTR, /* type */
2164 0, /* rightshift */
2165 2, /* size (0 = byte, 1 = short, 2 = long) */
2166 32, /* bitsize */
2167 FALSE, /* pc_relative */
2168 0, /* bitpos */
2169 complain_overflow_dont,/* complain_on_overflow */
2170 nds32_elf_ignore_reloc,/* special_function */
2171 "R_NDS32_PTR", /* name */
2172 FALSE, /* partial_inplace */
2173 0xffffffff, /* src_mask */
2174 0xffffffff, /* dst_mask */
2175 FALSE), /* pcrel_offset */
2176 HOWTO3 (R_NDS32_PTR_COUNT, /* type */
2177 0, /* rightshift */
2178 2, /* size (0 = byte, 1 = short, 2 = long) */
2179 32, /* bitsize */
2180 FALSE, /* pc_relative */
2181 0, /* bitpos */
2182 complain_overflow_dont,/* complain_on_overflow */
2183 nds32_elf_ignore_reloc,/* special_function */
2184 "R_NDS32_PTR_COUNT", /* name */
2185 FALSE, /* partial_inplace */
2186 0xffffffff, /* src_mask */
2187 0xffffffff, /* dst_mask */
2188 FALSE), /* pcrel_offset */
2189 HOWTO3 (R_NDS32_PTR_RESOLVED, /* type */
2190 0, /* rightshift */
2191 2, /* size (0 = byte, 1 = short, 2 = long) */
2192 32, /* bitsize */
2193 FALSE, /* pc_relative */
2194 0, /* bitpos */
2195 complain_overflow_dont,/* complain_on_overflow */
2196 nds32_elf_ignore_reloc,/* special_function */
2197 "R_NDS32_PTR_RESOLVED",/* name */
2198 FALSE, /* partial_inplace */
2199 0xffffffff, /* src_mask */
2200 0xffffffff, /* dst_mask */
2201 FALSE), /* pcrel_offset */
2202 HOWTO3 (R_NDS32_PLTBLOCK, /* type */
2203 0, /* rightshift */
2204 2, /* size (0 = byte, 1 = short, 2 = long) */
2205 32, /* bitsize */
2206 FALSE, /* pc_relative */
2207 0, /* bitpos */
2208 complain_overflow_dont,/* complain_on_overflow */
2209 nds32_elf_ignore_reloc,/* special_function */
2210 "R_NDS32_PLTBLOCK", /* name */
2211 FALSE, /* partial_inplace */
2212 0xffffffff, /* src_mask */
2213 0xffffffff, /* dst_mask */
2214 FALSE), /* pcrel_offset */
2215 HOWTO3 (R_NDS32_RELAX_REGION_BEGIN,/* type */
2216 0, /* rightshift */
2217 2, /* size (0 = byte, 1 = short, 2 = long) */
2218 32, /* bitsize */
2219 FALSE, /* pc_relative */
2220 0, /* bitpos */
2221 complain_overflow_dont,/* complain_on_overflow */
2222 nds32_elf_ignore_reloc,/* special_function */
2223 "R_NDS32_RELAX_REGION_BEGIN",/* name */
2224 FALSE, /* partial_inplace */
2225 0xffffffff, /* src_mask */
2226 0xffffffff, /* dst_mask */
2227 FALSE), /* pcrel_offset */
2228 HOWTO3 (R_NDS32_RELAX_REGION_END,/* type */
2229 0, /* rightshift */
2230 2, /* size (0 = byte, 1 = short, 2 = long) */
2231 32, /* bitsize */
2232 FALSE, /* pc_relative */
2233 0, /* bitpos */
2234 complain_overflow_dont,/* complain_on_overflow */
2235 nds32_elf_ignore_reloc,/* special_function */
2236 "R_NDS32_RELAX_REGION_END",/* name */
2237 FALSE, /* partial_inplace */
2238 0xffffffff, /* src_mask */
2239 0xffffffff, /* dst_mask */
2240 FALSE), /* pcrel_offset */
2241 HOWTO3 (R_NDS32_MINUEND, /* type */
2242 0, /* rightshift */
2243 2, /* size (0 = byte, 1 = short, 2 = long) */
2244 32, /* bitsize */
2245 FALSE, /* pc_relative */
2246 0, /* bitpos */
2247 complain_overflow_dont,/* complain_on_overflow */
2248 nds32_elf_ignore_reloc,/* special_function */
2249 "R_NDS32_MINUEND", /* name */
2250 FALSE, /* partial_inplace */
2251 0xffffffff, /* src_mask */
2252 0xffffffff, /* dst_mask */
2253 FALSE), /* pcrel_offset */
2254 HOWTO3 (R_NDS32_SUBTRAHEND, /* type */
2255 0, /* rightshift */
2256 2, /* size (0 = byte, 1 = short, 2 = long) */
2257 32, /* bitsize */
2258 FALSE, /* pc_relative */
2259 0, /* bitpos */
2260 complain_overflow_dont,/* complain_on_overflow */
2261 nds32_elf_ignore_reloc,/* special_function */
2262 "R_NDS32_SUBTRAHEND", /* name */
2263 FALSE, /* partial_inplace */
2264 0xffffffff, /* src_mask */
2265 0xffffffff, /* dst_mask */
2266 FALSE), /* pcrel_offset */
2267 HOWTO3 (R_NDS32_DIFF8, /* type */
2268 0, /* rightshift */
2269 0, /* size (0 = byte, 1 = short, 2 = long) */
2270 8, /* bitsize */
2271 FALSE, /* pc_relative */
2272 0, /* bitpos */
2273 complain_overflow_dont,/* complain_on_overflow */
2274 nds32_elf_ignore_reloc,/* special_function */
2275 "R_NDS32_DIFF8", /* name */
2276 FALSE, /* partial_inplace */
2277 0x000000ff, /* src_mask */
2278 0x000000ff, /* dst_mask */
2279 FALSE), /* pcrel_offset */
2280 HOWTO3 (R_NDS32_DIFF16, /* type */
2281 0, /* rightshift */
2282 1, /* size (0 = byte, 1 = short, 2 = long) */
2283 16, /* bitsize */
2284 FALSE, /* pc_relative */
2285 0, /* bitpos */
2286 complain_overflow_dont,/* complain_on_overflow */
2287 nds32_elf_ignore_reloc,/* special_function */
2288 "R_NDS32_DIFF16", /* name */
2289 FALSE, /* partial_inplace */
2290 0x0000ffff, /* src_mask */
2291 0x0000ffff, /* dst_mask */
2292 FALSE), /* pcrel_offset */
2293 HOWTO3 (R_NDS32_DIFF32, /* type */
2294 0, /* rightshift */
2295 2, /* size (0 = byte, 1 = short, 2 = long) */
2296 32, /* bitsize */
2297 FALSE, /* pc_relative */
2298 0, /* bitpos */
2299 complain_overflow_dont,/* complain_on_overflow */
2300 nds32_elf_ignore_reloc,/* special_function */
2301 "R_NDS32_DIFF32", /* name */
2302 FALSE, /* partial_inplace */
2303 0xffffffff, /* src_mask */
2304 0xffffffff, /* dst_mask */
2305 FALSE), /* pcrel_offset */
2306 HOWTO3 (R_NDS32_DIFF_ULEB128, /* type */
2307 0, /* rightshift */
2308 0, /* size (0 = byte, 1 = short, 2 = long) */
2309 0, /* bitsize */
2310 FALSE, /* pc_relative */
2311 0, /* bitpos */
2312 complain_overflow_dont,/* complain_on_overflow */
2313 nds32_elf_ignore_reloc,/* special_function */
2314 "R_NDS32_DIFF_ULEB128",/* name */
2315 FALSE, /* partial_inplace */
2316 0xffffffff, /* src_mask */
2317 0xffffffff, /* dst_mask */
2318 FALSE), /* pcrel_offset */
2319 HOWTO3 (R_NDS32_DATA, /* type */
2320 0, /* rightshift */
2321 2, /* size (0 = byte, 1 = short, 2 = long) */
2322 32, /* bitsize */
2323 FALSE, /* pc_relative */
2324 0, /* bitpos */
2325 complain_overflow_dont,/* complain_on_overflow */
2326 nds32_elf_ignore_reloc,/* special_function */
2327 "R_NDS32_DATA", /* name */
2328 FALSE, /* partial_inplace */
2329 0xffffffff, /* src_mask */
2330 0xffffffff, /* dst_mask */
2331 FALSE), /* pcrel_offset */
2332 HOWTO3 (R_NDS32_TRAN, /* type */
2333 0, /* rightshift */
2334 2, /* size (0 = byte, 1 = short, 2 = long) */
2335 32, /* bitsize */
2336 FALSE, /* pc_relative */
2337 0, /* bitpos */
2338 complain_overflow_dont,/* complain_on_overflow */
2339 nds32_elf_ignore_reloc,/* special_function */
2340 "R_NDS32_TRAN", /* name */
2341 FALSE, /* partial_inplace */
2342 0xffffffff, /* src_mask */
2343 0xffffffff, /* dst_mask */
2344 FALSE), /* pcrel_offset */
2345 HOWTO3 (R_NDS32_TLS_LE_ADD, /* type */
2346 0, /* rightshift */
2347 2, /* size (0 = byte, 1 = short, 2 = long) */
2348 32, /* bitsize */
2349 FALSE, /* pc_relative */
2350 0, /* bitpos */
2351 complain_overflow_dont,/* complain_on_overflow */
2352 nds32_elf_ignore_reloc,/* special_function */
2353 "R_NDS32_TLS_LE_ADD", /* name */
2354 FALSE, /* partial_inplace */
2355 0xffffffff, /* src_mask */
2356 0xffffffff, /* dst_mask */
2357 FALSE), /* pcrel_offset */
2358 HOWTO3 (R_NDS32_TLS_LE_LS, /* type */
2359 0, /* rightshift */
2360 2, /* size (0 = byte, 1 = short, 2 = long) */
2361 32, /* bitsize */
2362 FALSE, /* pc_relative */
2363 0, /* bitpos */
2364 complain_overflow_dont,/* complain_on_overflow */
2365 nds32_elf_ignore_reloc,/* special_function */
2366 "R_NDS32_TLS_LE_LS", /* name */
2367 FALSE, /* partial_inplace */
2368 0xffffffff, /* src_mask */
2369 0xffffffff, /* dst_mask */
2370 FALSE), /* pcrel_offset */
2371 HOWTO3 (R_NDS32_EMPTY, /* type */
2372 0, /* rightshift */
2373 2, /* size (0 = byte, 1 = short, 2 = long) */
2374 32, /* bitsize */
2375 FALSE, /* pc_relative */
2376 0, /* bitpos */
2377 complain_overflow_dont,/* complain_on_overflow */
2378 nds32_elf_ignore_reloc,/* special_function */
2379 "R_NDS32_EMPTY", /* name */
2380 FALSE, /* partial_inplace */
2381 0xffffffff, /* src_mask */
2382 0xffffffff, /* dst_mask */
2383 FALSE), /* pcrel_offset */
2384 /* TLS GD/LD description address base addition. */
2385 HOWTO3 (R_NDS32_TLS_DESC_ADD, /* type */
2386 0, /* rightshift */
2387 2, /* size (0 = byte, 1 = short, 2 = long) */
2388 32, /* bitsize */
2389 FALSE, /* pc_relative */
2390 0, /* bitpos */
2391 complain_overflow_dont,/* complain_on_overflow */
2392 nds32_elf_ignore_reloc,/* special_function */
2393 "R_NDS32_TLS_DESC_ADD",/* name */
2394 FALSE, /* partial_inplace */
2395 0xffffffff, /* src_mask */
2396 0xffffffff, /* dst_mask */
2397 FALSE), /* pcrel_offset */
2398 /* TLS GD/LD description function load. */
2399 HOWTO3 (R_NDS32_TLS_DESC_FUNC,/* type */
2400 0, /* rightshift */
2401 2, /* size (0 = byte, 1 = short, 2 = long) */
2402 32, /* bitsize */
2403 FALSE, /* pc_relative */
2404 0, /* bitpos */
2405 complain_overflow_dont,/* complain_on_overflow */
2406 nds32_elf_ignore_reloc,/* special_function */
2407 "R_NDS32_TLS_DESC_FUNC",/* name */
2408 FALSE, /* partial_inplace */
2409 0xffffffff, /* src_mask */
2410 0xffffffff, /* dst_mask */
2411 FALSE), /* pcrel_offset */
2412 /* TLS DESC resolve function call. */
2413 HOWTO3 (R_NDS32_TLS_DESC_CALL,/* type */
2414 0, /* rightshift */
2415 2, /* size (0 = byte, 1 = short, 2 = long) */
2416 32, /* bitsize */
2417 FALSE, /* pc_relative */
2418 0, /* bitpos */
2419 complain_overflow_dont,/* complain_on_overflow */
2420 nds32_elf_ignore_reloc,/* special_function */
2421 "R_NDS32_TLS_DESC_CALL",/* name */
2422 FALSE, /* partial_inplace */
2423 0xffffffff, /* src_mask */
2424 0xffffffff, /* dst_mask */
2425 FALSE), /* pcrel_offset */
2426 /* TLS DESC variable access. */
2427 HOWTO3 (R_NDS32_TLS_DESC_MEM, /* type */
2428 0, /* rightshift */
2429 2, /* size (0 = byte, 1 = short, 2 = long) */
2430 32, /* bitsize */
2431 FALSE, /* pc_relative */
2432 0, /* bitpos */
2433 complain_overflow_dont,/* complain_on_overflow */
2434 nds32_elf_ignore_reloc,/* special_function */
2435 "R_NDS32_TLS_DESC_MEM",/* name */
2436 FALSE, /* partial_inplace */
2437 0xffffffff, /* src_mask */
2438 0xffffffff, /* dst_mask */
2439 FALSE), /* pcrel_offset */
2440 /* TLS GD/LD description mark (@tlsdec). */
2441 HOWTO3 (R_NDS32_RELAX_REMOVE, /* type */
2442 0, /* rightshift */
2443 2, /* size (0 = byte, 1 = short, 2 = long) */
2444 32, /* bitsize */
2445 FALSE, /* pc_relative */
2446 0, /* bitpos */
2447 complain_overflow_dont,/* complain_on_overflow */
2448 nds32_elf_ignore_reloc,/* special_function */
2449 "R_NDS32_REMOVE", /* name */
2450 FALSE, /* partial_inplace */
2451 0xffffffff, /* src_mask */
2452 0xffffffff, /* dst_mask */
2453 FALSE), /* pcrel_offset */
2454 /* TLS GD/LD description mark (@tlsdec). */
2455 HOWTO3 (R_NDS32_RELAX_GROUP, /* type */
2456 0, /* rightshift */
2457 2, /* size (0 = byte, 1 = short, 2 = long) */
2458 32, /* bitsize */
2459 FALSE, /* pc_relative */
2460 0, /* bitpos */
2461 complain_overflow_dont,/* complain_on_overflow */
2462 nds32_elf_ignore_reloc,/* special_function */
2463 "R_NDS32_GROUP", /* name */
2464 FALSE, /* partial_inplace */
2465 0xffffffff, /* src_mask */
2466 0xffffffff, /* dst_mask */
2467 FALSE), /* pcrel_offset */
2468 HOWTO3 (R_NDS32_TLS_IEGP_LW, /* type */
2469 0, /* rightshift */
2470 2, /* size (0 = byte, 1 = short, 2 = long) */
2471 32, /* bitsize */
2472 FALSE, /* pc_relative */
2473 0, /* bitpos */
2474 complain_overflow_dont,/* complain_on_overflow */
2475 nds32_elf_ignore_reloc,/* special_function */
2476 "R_NDS32_TLS_IEGP_LW", /* name */
2477 FALSE, /* partial_inplace */
2478 0xffffffff, /* src_mask */
2479 0xffffffff, /* dst_mask */
2480 FALSE), /* pcrel_offset */
2481 /* LA and FLSI relaxation. */
2482 HOWTO3 (R_NDS32_LSI, /* type */
2483 0, /* rightshift */
2484 2, /* size (0 = byte, 1 = short, 2 = long) */
2485 32, /* bitsize */
2486 FALSE, /* pc_relative */
2487 0, /* bitpos */
2488 complain_overflow_dont,/* complain_on_overflow */
2489 nds32_elf_ignore_reloc,/* special_function */
2490 "R_NDS32_LSI", /* name */
2491 FALSE, /* partial_inplace */
2492 0xffffffff, /* src_mask */
2493 0xffffffff, /* dst_mask */
2494 FALSE),
2495 };
2496
2497 static unsigned long dl_tlsdesc_lazy_trampoline[] =
2498 {
2499 0x46200000, /* sethi $r2,#0x0 */
2500 0x58210000, /* ori $r2,$r2,#0x0 */
2501 0x40217400, /* add $r2,$r2,$gp */
2502 0x04210000, /* lwi $r2,[$r2+#0x0] */
2503 0x46300000, /* sethi $r3,#0x0 */
2504 0x58318000, /* ori $r3,$r3,#0x0 */
2505 0x4031f400, /* add $r3,$r3,$gp */
2506 0x4a000800, /* jr $r2 */
2507 };
2508
2509 static void
2510 nds32_put_trampoline (void *contents, const unsigned long *template,
2511 unsigned count)
2512 {
2513 unsigned ix;
2514
2515 for (ix = 0; ix != count; ix++)
2516 {
2517 unsigned long insn = template[ix];
2518 bfd_putb32 (insn, (char *) contents + ix * 4);
2519 }
2520 }
2521
2522 /* nds32_insertion_sort sorts an array with nmemb elements of size size.
2523 This prototype is the same as qsort (). */
2524
2525 void
2526 nds32_insertion_sort (void *base, size_t nmemb, size_t size,
2527 int (*compar) (const void *lhs, const void *rhs))
2528 {
2529 char *ptr = (char *) base;
2530 int i, j;
2531 char *tmp = xmalloc (size);
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 free (tmp);
2556 }
2557
2558 /* Sort relocation by r_offset.
2559
2560 We didn't use qsort () in stdlib, because quick-sort is not a stable sorting
2561 algorithm. Relocations at the same r_offset must keep their order.
2562 For example, RELAX_ENTRY must be the very first relocation entry.
2563
2564 Currently, this function implements insertion-sort.
2565
2566 FIXME: If we already sort them in assembler, why bother sort them
2567 here again? */
2568
2569 static int
2570 compar_reloc (const void *lhs, const void *rhs)
2571 {
2572 const Elf_Internal_Rela *l = (const Elf_Internal_Rela *) lhs;
2573 const Elf_Internal_Rela *r = (const Elf_Internal_Rela *) rhs;
2574
2575 if (l->r_offset > r->r_offset)
2576 return 1;
2577 else if (l->r_offset == r->r_offset)
2578 return 0;
2579 else
2580 return -1;
2581 }
2582
2583 /* Functions listed below are only used for old relocs.
2584 nds32_elf_9_pcrel_reloc
2585 nds32_elf_do_9_pcrel_reloc
2586 nds32_elf_hi20_reloc
2587 nds32_elf_relocate_hi20
2588 nds32_elf_lo12_reloc
2589 nds32_elf_sda15_reloc
2590 nds32_elf_generic_reloc. */
2591
2592 /* Handle the R_NDS32_9_PCREL & R_NDS32_9_PCREL_RELA reloc. */
2593
2594 static bfd_reloc_status_type
2595 nds32_elf_9_pcrel_reloc (bfd * abfd,
2596 arelent * reloc_entry,
2597 asymbol * symbol,
2598 void * data,
2599 asection * input_section,
2600 bfd * output_bfd,
2601 char ** error_message ATTRIBUTE_UNUSED)
2602 {
2603 /* This part is from bfd_elf_generic_reloc. */
2604 if (output_bfd != (bfd *) NULL
2605 && (symbol->flags & BSF_SECTION_SYM) == 0
2606 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2607 {
2608 reloc_entry->address += input_section->output_offset;
2609 return bfd_reloc_ok;
2610 }
2611
2612 if (output_bfd != NULL)
2613 {
2614 /* FIXME: See bfd_perform_relocation. Is this right? */
2615 return bfd_reloc_continue;
2616 }
2617
2618 return nds32_elf_do_9_pcrel_reloc (abfd, reloc_entry->howto,
2619 input_section,
2620 data, reloc_entry->address,
2621 symbol->section,
2622 (symbol->value
2623 + symbol->section->output_section->vma
2624 + symbol->section->output_offset),
2625 reloc_entry->addend);
2626 }
2627
2628 /* Utility to actually perform an R_NDS32_9_PCREL reloc. */
2629 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
2630
2631 static bfd_reloc_status_type
2632 nds32_elf_do_9_pcrel_reloc (bfd * abfd,
2633 reloc_howto_type * howto,
2634 asection * input_section,
2635 bfd_byte * data,
2636 bfd_vma offset,
2637 asection * symbol_section ATTRIBUTE_UNUSED,
2638 bfd_vma symbol_value,
2639 bfd_vma addend)
2640 {
2641 bfd_signed_vma relocation;
2642 unsigned short x;
2643 bfd_reloc_status_type status;
2644
2645 /* Sanity check the address (offset in section). */
2646 if (offset > bfd_get_section_limit (abfd, input_section))
2647 return bfd_reloc_outofrange;
2648
2649 relocation = symbol_value + addend;
2650 /* Make it pc relative. */
2651 relocation -= (input_section->output_section->vma
2652 + input_section->output_offset);
2653 /* These jumps mask off the lower two bits of the current address
2654 before doing pcrel calculations. */
2655 relocation -= (offset & -(bfd_vma) 2);
2656
2657 if (relocation < -ACCURATE_8BIT_S1 || relocation >= ACCURATE_8BIT_S1)
2658 status = bfd_reloc_overflow;
2659 else
2660 status = bfd_reloc_ok;
2661
2662 x = bfd_getb16 (data + offset);
2663
2664 relocation >>= howto->rightshift;
2665 relocation <<= howto->bitpos;
2666 x = (x & ~howto->dst_mask)
2667 | (((x & howto->src_mask) + relocation) & howto->dst_mask);
2668
2669 bfd_putb16 ((bfd_vma) x, data + offset);
2670
2671 return status;
2672 }
2673
2674 /* Handle the R_NDS32_HI20_[SU]LO relocs.
2675 HI20_SLO is for the add3 and load/store with displacement instructions.
2676 HI20 is for the or3 instruction.
2677 For R_NDS32_HI20_SLO, the lower 16 bits are sign extended when added to
2678 the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
2679 we must add one to the high 16 bytes (which will get subtracted off when
2680 the low 16 bits are added).
2681 These relocs have to be done in combination with an R_NDS32_LO12 reloc
2682 because there is a carry from the LO12 to the HI20. Here we just save
2683 the information we need; we do the actual relocation when we see the LO12.
2684 This code is copied from the elf32-mips.c. We also support an arbitrary
2685 number of HI20 relocs to be associated with a single LO12 reloc. The
2686 assembler sorts the relocs to ensure each HI20 immediately precedes its
2687 LO12. However if there are multiple copies, the assembler may not find
2688 the real LO12 so it picks the first one it finds. */
2689
2690 struct nds32_hi20
2691 {
2692 struct nds32_hi20 *next;
2693 bfd_byte *addr;
2694 bfd_vma addend;
2695 };
2696
2697 static struct nds32_hi20 *nds32_hi20_list;
2698
2699 static bfd_reloc_status_type
2700 nds32_elf_hi20_reloc (bfd *abfd ATTRIBUTE_UNUSED,
2701 arelent *reloc_entry,
2702 asymbol *symbol,
2703 void *data,
2704 asection *input_section,
2705 bfd *output_bfd,
2706 char **error_message ATTRIBUTE_UNUSED)
2707 {
2708 bfd_reloc_status_type ret;
2709 bfd_vma relocation;
2710 struct nds32_hi20 *n;
2711
2712 /* This part is from bfd_elf_generic_reloc.
2713 If we're relocating, and this an external symbol, we don't want
2714 to change anything. */
2715 if (output_bfd != (bfd *) NULL
2716 && (symbol->flags & BSF_SECTION_SYM) == 0 && reloc_entry->addend == 0)
2717 {
2718 reloc_entry->address += input_section->output_offset;
2719 return bfd_reloc_ok;
2720 }
2721
2722 /* Sanity check the address (offset in section). */
2723 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2724 return bfd_reloc_outofrange;
2725
2726 ret = bfd_reloc_ok;
2727 if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2728 ret = bfd_reloc_undefined;
2729
2730 if (bfd_is_com_section (symbol->section))
2731 relocation = 0;
2732 else
2733 relocation = symbol->value;
2734
2735 relocation += symbol->section->output_section->vma;
2736 relocation += symbol->section->output_offset;
2737 relocation += reloc_entry->addend;
2738
2739 /* Save the information, and let LO12 do the actual relocation. */
2740 n = (struct nds32_hi20 *) bfd_malloc ((bfd_size_type) sizeof *n);
2741 if (n == NULL)
2742 return bfd_reloc_outofrange;
2743
2744 n->addr = (bfd_byte *) data + reloc_entry->address;
2745 n->addend = relocation;
2746 n->next = nds32_hi20_list;
2747 nds32_hi20_list = n;
2748
2749 if (output_bfd != (bfd *) NULL)
2750 reloc_entry->address += input_section->output_offset;
2751
2752 return ret;
2753 }
2754
2755 /* Handle an NDS32 ELF HI20 reloc. */
2756
2757 static void
2758 nds32_elf_relocate_hi20 (bfd *input_bfd ATTRIBUTE_UNUSED,
2759 int type ATTRIBUTE_UNUSED,
2760 Elf_Internal_Rela *relhi,
2761 Elf_Internal_Rela *rello,
2762 bfd_byte *contents,
2763 bfd_vma addend)
2764 {
2765 unsigned long insn;
2766 bfd_vma addlo;
2767
2768 insn = bfd_getb32 (contents + relhi->r_offset);
2769
2770 addlo = bfd_getb32 (contents + rello->r_offset);
2771 addlo &= 0xfff;
2772
2773 addend += ((insn & 0xfffff) << 20) + addlo;
2774
2775 insn = (insn & 0xfff00000) | ((addend >> 12) & 0xfffff);
2776 bfd_putb32 (insn, contents + relhi->r_offset);
2777 }
2778
2779 /* Do an R_NDS32_LO12 relocation. This is a straightforward 12 bit
2780 inplace relocation; this function exists in order to do the
2781 R_NDS32_HI20_[SU]LO relocation described above. */
2782
2783 static bfd_reloc_status_type
2784 nds32_elf_lo12_reloc (bfd *input_bfd, arelent *reloc_entry, asymbol *symbol,
2785 void *data, asection *input_section, bfd *output_bfd,
2786 char **error_message)
2787 {
2788 /* This part is from bfd_elf_generic_reloc.
2789 If we're relocating, and this an external symbol, we don't want
2790 to change anything. */
2791 if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2792 && reloc_entry->addend == 0)
2793 {
2794 reloc_entry->address += input_section->output_offset;
2795 return bfd_reloc_ok;
2796 }
2797
2798 if (nds32_hi20_list != NULL)
2799 {
2800 struct nds32_hi20 *l;
2801
2802 l = nds32_hi20_list;
2803 while (l != NULL)
2804 {
2805 unsigned long insn;
2806 unsigned long val;
2807 unsigned long vallo;
2808 struct nds32_hi20 *next;
2809
2810 /* Do the HI20 relocation. Note that we actually don't need
2811 to know anything about the LO12 itself, except where to
2812 find the low 12 bits of the addend needed by the LO12. */
2813 insn = bfd_getb32 (l->addr);
2814 vallo = bfd_getb32 ((bfd_byte *) data + reloc_entry->address);
2815 vallo &= 0xfff;
2816 switch (reloc_entry->howto->type)
2817 {
2818 case R_NDS32_LO12S3:
2819 vallo <<= 3;
2820 break;
2821
2822 case R_NDS32_LO12S2:
2823 vallo <<= 2;
2824 break;
2825
2826 case R_NDS32_LO12S1:
2827 vallo <<= 1;
2828 break;
2829
2830 case R_NDS32_LO12S0:
2831 vallo <<= 0;
2832 break;
2833 }
2834
2835 val = ((insn & 0xfffff) << 12) + vallo;
2836 val += l->addend;
2837
2838 insn = (insn & ~(bfd_vma) 0xfffff) | ((val >> 12) & 0xfffff);
2839 bfd_putb32 ((bfd_vma) insn, l->addr);
2840
2841 next = l->next;
2842 free (l);
2843 l = next;
2844 }
2845
2846 nds32_hi20_list = NULL;
2847 }
2848
2849 /* Now do the LO12 reloc in the usual way.
2850 ??? It would be nice to call bfd_elf_generic_reloc here,
2851 but we have partial_inplace set. bfd_elf_generic_reloc will
2852 pass the handling back to bfd_install_relocation which will install
2853 a section relative addend which is wrong. */
2854 return nds32_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
2855 input_section, output_bfd, error_message);
2856 }
2857
2858 /* Do generic partial_inplace relocation.
2859 This is a local replacement for bfd_elf_generic_reloc. */
2860
2861 static bfd_reloc_status_type
2862 nds32_elf_generic_reloc (bfd *input_bfd, arelent *reloc_entry,
2863 asymbol *symbol, void *data, asection *input_section,
2864 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2865 {
2866 bfd_reloc_status_type ret;
2867 bfd_vma relocation;
2868 bfd_byte *inplace_address;
2869
2870 /* This part is from bfd_elf_generic_reloc.
2871 If we're relocating, and this an external symbol, we don't want
2872 to change anything. */
2873 if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2874 && reloc_entry->addend == 0)
2875 {
2876 reloc_entry->address += input_section->output_offset;
2877 return bfd_reloc_ok;
2878 }
2879
2880 /* Now do the reloc in the usual way.
2881 ??? It would be nice to call bfd_elf_generic_reloc here,
2882 but we have partial_inplace set. bfd_elf_generic_reloc will
2883 pass the handling back to bfd_install_relocation which will install
2884 a section relative addend which is wrong. */
2885
2886 /* Sanity check the address (offset in section). */
2887 if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section))
2888 return bfd_reloc_outofrange;
2889
2890 ret = bfd_reloc_ok;
2891 if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2892 ret = bfd_reloc_undefined;
2893
2894 if (bfd_is_com_section (symbol->section) || output_bfd != (bfd *) NULL)
2895 relocation = 0;
2896 else
2897 relocation = symbol->value;
2898
2899 /* Only do this for a final link. */
2900 if (output_bfd == (bfd *) NULL)
2901 {
2902 relocation += symbol->section->output_section->vma;
2903 relocation += symbol->section->output_offset;
2904 }
2905
2906 relocation += reloc_entry->addend;
2907 switch (reloc_entry->howto->type)
2908 {
2909 case R_NDS32_LO12S3:
2910 relocation >>= 3;
2911 break;
2912
2913 case R_NDS32_LO12S2:
2914 relocation >>= 2;
2915 break;
2916
2917 case R_NDS32_LO12S1:
2918 relocation >>= 1;
2919 break;
2920
2921 case R_NDS32_LO12S0:
2922 default:
2923 relocation >>= 0;
2924 break;
2925 }
2926
2927 inplace_address = (bfd_byte *) data + reloc_entry->address;
2928
2929 #define DOIT(x) \
2930 x = ((x & ~reloc_entry->howto->dst_mask) | \
2931 (((x & reloc_entry->howto->src_mask) + relocation) & \
2932 reloc_entry->howto->dst_mask))
2933
2934 switch (reloc_entry->howto->size)
2935 {
2936 case 1:
2937 {
2938 short x = bfd_getb16 (inplace_address);
2939
2940 DOIT (x);
2941 bfd_putb16 ((bfd_vma) x, inplace_address);
2942 }
2943 break;
2944 case 2:
2945 {
2946 unsigned long x = bfd_getb32 (inplace_address);
2947
2948 DOIT (x);
2949 bfd_putb32 ((bfd_vma) x, inplace_address);
2950 }
2951 break;
2952 default:
2953 BFD_ASSERT (0);
2954 }
2955
2956 if (output_bfd != (bfd *) NULL)
2957 reloc_entry->address += input_section->output_offset;
2958
2959 return ret;
2960 }
2961
2962 /* Handle the R_NDS32_SDA15 reloc.
2963 This reloc is used to compute the address of objects in the small data area
2964 and to perform loads and stores from that area.
2965 The lower 15 bits are sign extended and added to the register specified
2966 in the instruction, which is assumed to point to _SDA_BASE_.
2967
2968 Since the lower 15 bits offset is left-shifted 0, 1 or 2 bits depending on
2969 the access size, this must be taken care of. */
2970
2971 static bfd_reloc_status_type
2972 nds32_elf_sda15_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2973 asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2974 asection *input_section, bfd *output_bfd,
2975 char **error_message ATTRIBUTE_UNUSED)
2976 {
2977 /* This part is from bfd_elf_generic_reloc. */
2978 if (output_bfd != (bfd *) NULL
2979 && (symbol->flags & BSF_SECTION_SYM) == 0
2980 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2981 {
2982 reloc_entry->address += input_section->output_offset;
2983 return bfd_reloc_ok;
2984 }
2985
2986 if (output_bfd != NULL)
2987 {
2988 /* FIXME: See bfd_perform_relocation. Is this right? */
2989 return bfd_reloc_continue;
2990 }
2991
2992 /* FIXME: not sure what to do here yet. But then again, the linker
2993 may never call us. */
2994 abort ();
2995 }
2996
2997 /* nds32_elf_ignore_reloc is the special function for
2998 relocation types which don't need to be relocated
2999 like relaxation relocation types.
3000 This function simply return bfd_reloc_ok when it is
3001 invoked. */
3002
3003 static bfd_reloc_status_type
3004 nds32_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
3005 asymbol *symbol ATTRIBUTE_UNUSED,
3006 void *data ATTRIBUTE_UNUSED, asection *input_section,
3007 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
3008 {
3009 if (output_bfd != NULL)
3010 reloc_entry->address += input_section->output_offset;
3011
3012 return bfd_reloc_ok;
3013 }
3014 \f
3015
3016 /* Map BFD reloc types to NDS32 ELF reloc types. */
3017
3018 struct nds32_reloc_map_entry
3019 {
3020 bfd_reloc_code_real_type bfd_reloc_val;
3021 unsigned char elf_reloc_val;
3022 };
3023
3024 static const struct nds32_reloc_map_entry nds32_reloc_map[] =
3025 {
3026 {BFD_RELOC_NONE, R_NDS32_NONE},
3027 {BFD_RELOC_16, R_NDS32_16_RELA},
3028 {BFD_RELOC_32, R_NDS32_32_RELA},
3029 {BFD_RELOC_VTABLE_INHERIT, R_NDS32_RELA_GNU_VTINHERIT},
3030 {BFD_RELOC_VTABLE_ENTRY, R_NDS32_RELA_GNU_VTENTRY},
3031
3032 {BFD_RELOC_NDS32_20, R_NDS32_20_RELA},
3033 {BFD_RELOC_NDS32_9_PCREL, R_NDS32_9_PCREL_RELA},
3034 {BFD_RELOC_NDS32_WORD_9_PCREL, R_NDS32_WORD_9_PCREL_RELA},
3035 {BFD_RELOC_NDS32_15_PCREL, R_NDS32_15_PCREL_RELA},
3036 {BFD_RELOC_NDS32_17_PCREL, R_NDS32_17_PCREL_RELA},
3037 {BFD_RELOC_NDS32_25_PCREL, R_NDS32_25_PCREL_RELA},
3038 {BFD_RELOC_NDS32_HI20, R_NDS32_HI20_RELA},
3039 {BFD_RELOC_NDS32_LO12S3, R_NDS32_LO12S3_RELA},
3040 {BFD_RELOC_NDS32_LO12S2, R_NDS32_LO12S2_RELA},
3041 {BFD_RELOC_NDS32_LO12S1, R_NDS32_LO12S1_RELA},
3042 {BFD_RELOC_NDS32_LO12S0, R_NDS32_LO12S0_RELA},
3043 {BFD_RELOC_NDS32_LO12S0_ORI, R_NDS32_LO12S0_ORI_RELA},
3044 {BFD_RELOC_NDS32_SDA15S3, R_NDS32_SDA15S3_RELA},
3045 {BFD_RELOC_NDS32_SDA15S2, R_NDS32_SDA15S2_RELA},
3046 {BFD_RELOC_NDS32_SDA15S1, R_NDS32_SDA15S1_RELA},
3047 {BFD_RELOC_NDS32_SDA15S0, R_NDS32_SDA15S0_RELA},
3048 {BFD_RELOC_NDS32_SDA16S3, R_NDS32_SDA16S3_RELA},
3049 {BFD_RELOC_NDS32_SDA17S2, R_NDS32_SDA17S2_RELA},
3050 {BFD_RELOC_NDS32_SDA18S1, R_NDS32_SDA18S1_RELA},
3051 {BFD_RELOC_NDS32_SDA19S0, R_NDS32_SDA19S0_RELA},
3052 {BFD_RELOC_NDS32_GOT20, R_NDS32_GOT20},
3053 {BFD_RELOC_NDS32_9_PLTREL, R_NDS32_9_PLTREL},
3054 {BFD_RELOC_NDS32_25_PLTREL, R_NDS32_25_PLTREL},
3055 {BFD_RELOC_NDS32_COPY, R_NDS32_COPY},
3056 {BFD_RELOC_NDS32_GLOB_DAT, R_NDS32_GLOB_DAT},
3057 {BFD_RELOC_NDS32_JMP_SLOT, R_NDS32_JMP_SLOT},
3058 {BFD_RELOC_NDS32_RELATIVE, R_NDS32_RELATIVE},
3059 {BFD_RELOC_NDS32_GOTOFF, R_NDS32_GOTOFF},
3060 {BFD_RELOC_NDS32_GOTOFF_HI20, R_NDS32_GOTOFF_HI20},
3061 {BFD_RELOC_NDS32_GOTOFF_LO12, R_NDS32_GOTOFF_LO12},
3062 {BFD_RELOC_NDS32_GOTPC20, R_NDS32_GOTPC20},
3063 {BFD_RELOC_NDS32_GOT_HI20, R_NDS32_GOT_HI20},
3064 {BFD_RELOC_NDS32_GOT_LO12, R_NDS32_GOT_LO12},
3065 {BFD_RELOC_NDS32_GOTPC_HI20, R_NDS32_GOTPC_HI20},
3066 {BFD_RELOC_NDS32_GOTPC_LO12, R_NDS32_GOTPC_LO12},
3067 {BFD_RELOC_NDS32_INSN16, R_NDS32_INSN16},
3068 {BFD_RELOC_NDS32_LABEL, R_NDS32_LABEL},
3069 {BFD_RELOC_NDS32_LONGCALL1, R_NDS32_LONGCALL1},
3070 {BFD_RELOC_NDS32_LONGCALL2, R_NDS32_LONGCALL2},
3071 {BFD_RELOC_NDS32_LONGCALL3, R_NDS32_LONGCALL3},
3072 {BFD_RELOC_NDS32_LONGJUMP1, R_NDS32_LONGJUMP1},
3073 {BFD_RELOC_NDS32_LONGJUMP2, R_NDS32_LONGJUMP2},
3074 {BFD_RELOC_NDS32_LONGJUMP3, R_NDS32_LONGJUMP3},
3075 {BFD_RELOC_NDS32_LOADSTORE, R_NDS32_LOADSTORE},
3076 {BFD_RELOC_NDS32_9_FIXED, R_NDS32_9_FIXED_RELA},
3077 {BFD_RELOC_NDS32_15_FIXED, R_NDS32_15_FIXED_RELA},
3078 {BFD_RELOC_NDS32_17_FIXED, R_NDS32_17_FIXED_RELA},
3079 {BFD_RELOC_NDS32_25_FIXED, R_NDS32_25_FIXED_RELA},
3080 {BFD_RELOC_NDS32_LONGCALL4, R_NDS32_LONGCALL4},
3081 {BFD_RELOC_NDS32_LONGCALL5, R_NDS32_LONGCALL5},
3082 {BFD_RELOC_NDS32_LONGCALL6, R_NDS32_LONGCALL6},
3083 {BFD_RELOC_NDS32_LONGJUMP4, R_NDS32_LONGJUMP4},
3084 {BFD_RELOC_NDS32_LONGJUMP5, R_NDS32_LONGJUMP5},
3085 {BFD_RELOC_NDS32_LONGJUMP6, R_NDS32_LONGJUMP6},
3086 {BFD_RELOC_NDS32_LONGJUMP7, R_NDS32_LONGJUMP7},
3087 {BFD_RELOC_NDS32_PLTREL_HI20, R_NDS32_PLTREL_HI20},
3088 {BFD_RELOC_NDS32_PLTREL_LO12, R_NDS32_PLTREL_LO12},
3089 {BFD_RELOC_NDS32_PLT_GOTREL_HI20, R_NDS32_PLT_GOTREL_HI20},
3090 {BFD_RELOC_NDS32_PLT_GOTREL_LO12, R_NDS32_PLT_GOTREL_LO12},
3091 {BFD_RELOC_NDS32_SDA12S2_DP, R_NDS32_SDA12S2_DP_RELA},
3092 {BFD_RELOC_NDS32_SDA12S2_SP, R_NDS32_SDA12S2_SP_RELA},
3093 {BFD_RELOC_NDS32_LO12S2_DP, R_NDS32_LO12S2_DP_RELA},
3094 {BFD_RELOC_NDS32_LO12S2_SP, R_NDS32_LO12S2_SP_RELA},
3095 {BFD_RELOC_NDS32_DWARF2_OP1, R_NDS32_DWARF2_OP1_RELA},
3096 {BFD_RELOC_NDS32_DWARF2_OP2, R_NDS32_DWARF2_OP2_RELA},
3097 {BFD_RELOC_NDS32_DWARF2_LEB, R_NDS32_DWARF2_LEB_RELA},
3098 {BFD_RELOC_NDS32_UPDATE_TA, R_NDS32_UPDATE_TA_RELA},
3099 {BFD_RELOC_NDS32_PLT_GOTREL_LO20, R_NDS32_PLT_GOTREL_LO20},
3100 {BFD_RELOC_NDS32_PLT_GOTREL_LO15, R_NDS32_PLT_GOTREL_LO15},
3101 {BFD_RELOC_NDS32_PLT_GOTREL_LO19, R_NDS32_PLT_GOTREL_LO19},
3102 {BFD_RELOC_NDS32_GOT_LO15, R_NDS32_GOT_LO15},
3103 {BFD_RELOC_NDS32_GOT_LO19, R_NDS32_GOT_LO19},
3104 {BFD_RELOC_NDS32_GOTOFF_LO15, R_NDS32_GOTOFF_LO15},
3105 {BFD_RELOC_NDS32_GOTOFF_LO19, R_NDS32_GOTOFF_LO19},
3106 {BFD_RELOC_NDS32_GOT15S2, R_NDS32_GOT15S2_RELA},
3107 {BFD_RELOC_NDS32_GOT17S2, R_NDS32_GOT17S2_RELA},
3108 {BFD_RELOC_NDS32_5, R_NDS32_5_RELA},
3109 {BFD_RELOC_NDS32_10_UPCREL, R_NDS32_10_UPCREL_RELA},
3110 {BFD_RELOC_NDS32_SDA_FP7U2_RELA, R_NDS32_SDA_FP7U2_RELA},
3111 {BFD_RELOC_NDS32_RELAX_ENTRY, R_NDS32_RELAX_ENTRY},
3112 {BFD_RELOC_NDS32_GOT_SUFF, R_NDS32_GOT_SUFF},
3113 {BFD_RELOC_NDS32_GOTOFF_SUFF, R_NDS32_GOTOFF_SUFF},
3114 {BFD_RELOC_NDS32_PLT_GOT_SUFF, R_NDS32_PLT_GOT_SUFF},
3115 {BFD_RELOC_NDS32_MULCALL_SUFF, R_NDS32_MULCALL_SUFF},
3116 {BFD_RELOC_NDS32_PTR, R_NDS32_PTR},
3117 {BFD_RELOC_NDS32_PTR_COUNT, R_NDS32_PTR_COUNT},
3118 {BFD_RELOC_NDS32_PTR_RESOLVED, R_NDS32_PTR_RESOLVED},
3119 {BFD_RELOC_NDS32_PLTBLOCK, R_NDS32_PLTBLOCK},
3120 {BFD_RELOC_NDS32_RELAX_REGION_BEGIN, R_NDS32_RELAX_REGION_BEGIN},
3121 {BFD_RELOC_NDS32_RELAX_REGION_END, R_NDS32_RELAX_REGION_END},
3122 {BFD_RELOC_NDS32_MINUEND, R_NDS32_MINUEND},
3123 {BFD_RELOC_NDS32_SUBTRAHEND, R_NDS32_SUBTRAHEND},
3124 {BFD_RELOC_NDS32_DIFF8, R_NDS32_DIFF8},
3125 {BFD_RELOC_NDS32_DIFF16, R_NDS32_DIFF16},
3126 {BFD_RELOC_NDS32_DIFF32, R_NDS32_DIFF32},
3127 {BFD_RELOC_NDS32_DIFF_ULEB128, R_NDS32_DIFF_ULEB128},
3128 {BFD_RELOC_NDS32_EMPTY, R_NDS32_EMPTY},
3129 {BFD_RELOC_NDS32_25_ABS, R_NDS32_25_ABS_RELA},
3130 {BFD_RELOC_NDS32_DATA, R_NDS32_DATA},
3131 {BFD_RELOC_NDS32_TRAN, R_NDS32_TRAN},
3132 {BFD_RELOC_NDS32_17IFC_PCREL, R_NDS32_17IFC_PCREL_RELA},
3133 {BFD_RELOC_NDS32_10IFCU_PCREL, R_NDS32_10IFCU_PCREL_RELA},
3134 /* Not sure. */
3135 {BFD_RELOC_NDS32_TPOFF, R_NDS32_TLS_TPOFF},
3136 /* Missing: BFD_RELOC_NDS32_GOTTPOFF. */
3137 {BFD_RELOC_NDS32_TLS_LE_HI20, R_NDS32_TLS_LE_HI20},
3138 {BFD_RELOC_NDS32_TLS_LE_LO12, R_NDS32_TLS_LE_LO12},
3139 {BFD_RELOC_NDS32_TLS_LE_20, R_NDS32_TLS_LE_20},
3140 {BFD_RELOC_NDS32_TLS_LE_15S0, R_NDS32_TLS_LE_15S0},
3141 {BFD_RELOC_NDS32_TLS_LE_15S1, R_NDS32_TLS_LE_15S1},
3142 {BFD_RELOC_NDS32_TLS_LE_15S2, R_NDS32_TLS_LE_15S2},
3143 {BFD_RELOC_NDS32_TLS_LE_ADD, R_NDS32_TLS_LE_ADD},
3144 {BFD_RELOC_NDS32_TLS_LE_LS, R_NDS32_TLS_LE_LS},
3145 {BFD_RELOC_NDS32_TLS_IE_HI20, R_NDS32_TLS_IE_HI20},
3146 {BFD_RELOC_NDS32_TLS_IE_LO12, R_NDS32_TLS_IE_LO12},
3147 {BFD_RELOC_NDS32_TLS_IE_LO12S2, R_NDS32_TLS_IE_LO12S2},
3148 {BFD_RELOC_NDS32_TLS_IEGP_HI20, R_NDS32_TLS_IEGP_HI20},
3149 {BFD_RELOC_NDS32_TLS_IEGP_LO12, R_NDS32_TLS_IEGP_LO12},
3150 {BFD_RELOC_NDS32_TLS_IEGP_LO12S2, R_NDS32_TLS_IEGP_LO12S2},
3151 {BFD_RELOC_NDS32_TLS_IEGP_LW, R_NDS32_TLS_IEGP_LW},
3152 {BFD_RELOC_NDS32_TLS_DESC, R_NDS32_TLS_DESC},
3153 {BFD_RELOC_NDS32_TLS_DESC_HI20, R_NDS32_TLS_DESC_HI20},
3154 {BFD_RELOC_NDS32_TLS_DESC_LO12, R_NDS32_TLS_DESC_LO12},
3155 {BFD_RELOC_NDS32_TLS_DESC_20, R_NDS32_TLS_DESC_20},
3156 {BFD_RELOC_NDS32_TLS_DESC_SDA17S2, R_NDS32_TLS_DESC_SDA17S2},
3157 {BFD_RELOC_NDS32_TLS_DESC_ADD, R_NDS32_TLS_DESC_ADD},
3158 {BFD_RELOC_NDS32_TLS_DESC_FUNC, R_NDS32_TLS_DESC_FUNC},
3159 {BFD_RELOC_NDS32_TLS_DESC_CALL, R_NDS32_TLS_DESC_CALL},
3160 {BFD_RELOC_NDS32_TLS_DESC_MEM, R_NDS32_TLS_DESC_MEM},
3161 {BFD_RELOC_NDS32_REMOVE, R_NDS32_RELAX_REMOVE},
3162 {BFD_RELOC_NDS32_GROUP, R_NDS32_RELAX_GROUP},
3163 {BFD_RELOC_NDS32_LSI, R_NDS32_LSI},
3164 };
3165
3166 /* Patch tag. */
3167
3168 /* Reserve space for COUNT dynamic relocations in relocation selection
3169 SRELOC. */
3170
3171 static inline void
3172 elf32_nds32_allocate_dynrelocs (struct bfd_link_info *info, asection *sreloc,
3173 bfd_size_type count)
3174 {
3175 BFD_ASSERT (elf_hash_table (info)->dynamic_sections_created);
3176 if (sreloc == NULL)
3177 abort ();
3178 sreloc->size += sizeof (Elf32_External_Rela) * count;
3179 }
3180
3181 static reloc_howto_type *
3182 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
3183 const char *r_name)
3184 {
3185 unsigned int i;
3186
3187 for (i = 0; i < ARRAY_SIZE (nds32_elf_howto_table); i++)
3188 if (nds32_elf_howto_table[i].name != NULL
3189 && strcasecmp (nds32_elf_howto_table[i].name, r_name) == 0)
3190 return &nds32_elf_howto_table[i];
3191
3192 for (i = 0; i < ARRAY_SIZE (nds32_elf_relax_howto_table); i++)
3193 if (nds32_elf_relax_howto_table[i].name != NULL
3194 && strcasecmp (nds32_elf_relax_howto_table[i].name, r_name) == 0)
3195 return &nds32_elf_relax_howto_table[i];
3196
3197 return NULL;
3198 }
3199
3200 static reloc_howto_type *
3201 bfd_elf32_bfd_reloc_type_table_lookup (enum elf_nds32_reloc_type code)
3202 {
3203 if (code < R_NDS32_RELAX_ENTRY)
3204 {
3205 BFD_ASSERT (code < ARRAY_SIZE (nds32_elf_howto_table));
3206 return &nds32_elf_howto_table[code];
3207 }
3208 else
3209 {
3210 if ((size_t) (code - R_NDS32_RELAX_ENTRY)
3211 >= ARRAY_SIZE (nds32_elf_relax_howto_table))
3212 {
3213 int i = code;
3214 i += 1;
3215 }
3216
3217 BFD_ASSERT ((size_t) (code - R_NDS32_RELAX_ENTRY)
3218 < ARRAY_SIZE (nds32_elf_relax_howto_table));
3219 return &nds32_elf_relax_howto_table[code - R_NDS32_RELAX_ENTRY];
3220 }
3221 }
3222
3223 static reloc_howto_type *
3224 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
3225 bfd_reloc_code_real_type code)
3226 {
3227 unsigned int i;
3228
3229 for (i = 0; i < ARRAY_SIZE (nds32_reloc_map); i++)
3230 {
3231 if (nds32_reloc_map[i].bfd_reloc_val == code)
3232 return bfd_elf32_bfd_reloc_type_table_lookup
3233 (nds32_reloc_map[i].elf_reloc_val);
3234 }
3235
3236 return NULL;
3237 }
3238
3239 /* Set the howto pointer for an NDS32 ELF reloc. */
3240
3241 static bfd_boolean
3242 nds32_info_to_howto_rel (bfd *abfd, arelent *cache_ptr,
3243 Elf_Internal_Rela *dst)
3244 {
3245 enum elf_nds32_reloc_type r_type;
3246
3247 r_type = ELF32_R_TYPE (dst->r_info);
3248 if (r_type > R_NDS32_GNU_VTENTRY)
3249 {
3250 /* xgettext:c-format */
3251 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3252 abfd, r_type);
3253 bfd_set_error (bfd_error_bad_value);
3254 return FALSE;
3255 }
3256
3257 BFD_ASSERT (ELF32_R_TYPE (dst->r_info) <= R_NDS32_GNU_VTENTRY);
3258 cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
3259 return TRUE;
3260 }
3261
3262 static bfd_boolean
3263 nds32_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
3264 Elf_Internal_Rela *dst)
3265 {
3266 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
3267
3268 if ((r_type == R_NDS32_NONE)
3269 || ((r_type > R_NDS32_GNU_VTENTRY)
3270 && (r_type < R_NDS32_max)))
3271 {
3272 cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
3273 return TRUE;
3274 }
3275
3276 /* xgettext:c-format */
3277 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, r_type);
3278 bfd_set_error (bfd_error_bad_value);
3279 return FALSE;
3280 }
3281
3282 /* Support for core dump NOTE sections.
3283 Reference to include/linux/elfcore.h in Linux. */
3284
3285 static bfd_boolean
3286 nds32_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3287 {
3288 int offset;
3289 size_t size;
3290
3291 switch (note->descsz)
3292 {
3293 case 0x114:
3294 /* Linux/NDS32 32-bit, ABI1. */
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 = 200;
3305 break;
3306
3307 case 0xfc:
3308 /* Linux/NDS32 32-bit. */
3309
3310 /* pr_cursig */
3311 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3312
3313 /* pr_pid */
3314 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3315
3316 /* pr_reg */
3317 offset = 72;
3318 size = 176;
3319 break;
3320
3321 default:
3322 return FALSE;
3323 }
3324
3325 /* Make a ".reg" section. */
3326 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3327 size, note->descpos + offset);
3328 }
3329
3330 static bfd_boolean
3331 nds32_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3332 {
3333 switch (note->descsz)
3334 {
3335 case 124:
3336 /* Linux/NDS32. */
3337
3338 /* __kernel_uid_t, __kernel_gid_t are short on NDS32 platform. */
3339 elf_tdata (abfd)->core->program =
3340 _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
3341 elf_tdata (abfd)->core->command =
3342 _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
3343 break;
3344
3345 default:
3346 return FALSE;
3347 }
3348
3349 /* Note that for some reason, a spurious space is tacked
3350 onto the end of the args in some (at least one anyway)
3351 implementations, so strip it off if it exists. */
3352 {
3353 char *command = elf_tdata (abfd)->core->command;
3354 int n = strlen (command);
3355
3356 if (0 < n && command[n - 1] == ' ')
3357 command[n - 1] = '\0';
3358 }
3359
3360 return TRUE;
3361 }
3362
3363 /* Hook called by the linker routine which adds symbols from an object
3364 file. We must handle the special NDS32 section numbers here.
3365 We also keep watching for whether we need to create the sdata special
3366 linker sections. */
3367
3368 static bfd_boolean
3369 nds32_elf_add_symbol_hook (bfd *abfd,
3370 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3371 Elf_Internal_Sym *sym,
3372 const char **namep ATTRIBUTE_UNUSED,
3373 flagword *flagsp ATTRIBUTE_UNUSED,
3374 asection **secp, bfd_vma *valp)
3375 {
3376 switch (sym->st_shndx)
3377 {
3378 case SHN_COMMON:
3379 /* Common symbols less than the GP size are automatically
3380 treated as SHN_MIPS_SCOMMON symbols. */
3381 if (sym->st_size > elf_gp_size (abfd)
3382 || ELF_ST_TYPE (sym->st_info) == STT_TLS)
3383 break;
3384
3385 /* st_value is the alignemnt constraint.
3386 That might be its actual size if it is an array or structure. */
3387 switch (sym->st_value)
3388 {
3389 case 1:
3390 *secp = bfd_make_section_old_way (abfd, ".scommon_b");
3391 break;
3392 case 2:
3393 *secp = bfd_make_section_old_way (abfd, ".scommon_h");
3394 break;
3395 case 4:
3396 *secp = bfd_make_section_old_way (abfd, ".scommon_w");
3397 break;
3398 case 8:
3399 *secp = bfd_make_section_old_way (abfd, ".scommon_d");
3400 break;
3401 default:
3402 return TRUE;
3403 }
3404
3405 (*secp)->flags |= SEC_IS_COMMON;
3406 *valp = sym->st_size;
3407 break;
3408 }
3409
3410 return TRUE;
3411 }
3412
3413 /* This function can figure out the best location for a base register to access
3414 data relative to this base register
3415 INPUT:
3416 sda_d0: size of first DOUBLE WORD data section
3417 sda_w0: size of first WORD data section
3418 sda_h0: size of first HALF WORD data section
3419 sda_b : size of BYTE data section
3420 sda_hi: size of second HALF WORD data section
3421 sda_w1: size of second WORD data section
3422 sda_d1: size of second DOUBLE WORD data section
3423 OUTPUT:
3424 offset (always positive) from the beginning of sda_d0 if OK
3425 a negative error value if fail
3426 NOTE:
3427 these 7 sections have to be located back to back if exist
3428 a pass in 0 value for non-existing section */
3429
3430 /* Due to the interpretation of simm15 field of load/store depending on
3431 data accessing size, the organization of base register relative data shall
3432 like the following figure
3433 -------------------------------------------
3434 | DOUBLE WORD sized data (range +/- 128K)
3435 -------------------------------------------
3436 | WORD sized data (range +/- 64K)
3437 -------------------------------------------
3438 | HALF WORD sized data (range +/- 32K)
3439 -------------------------------------------
3440 | BYTE sized data (range +/- 16K)
3441 -------------------------------------------
3442 | HALF WORD sized data (range +/- 32K)
3443 -------------------------------------------
3444 | WORD sized data (range +/- 64K)
3445 -------------------------------------------
3446 | DOUBLE WORD sized data (range +/- 128K)
3447 -------------------------------------------
3448 Its base register shall be set to access these data freely. */
3449
3450 /* We have to figure out the SDA_BASE value, so that we can adjust the
3451 symbol value correctly. We look up the symbol _SDA_BASE_ in the output
3452 BFD. If we can't find it, we're stuck. We cache it in the ELF
3453 target data. We don't need to adjust the symbol value for an
3454 external symbol if we are producing relocatable output. */
3455
3456 static asection *sda_rela_sec = NULL;
3457
3458 #define SDA_SECTION_NUM 10
3459
3460 static bfd_reloc_status_type
3461 nds32_elf_final_sda_base (bfd * output_bfd,
3462 struct bfd_link_info * info,
3463 bfd_vma * psb,
3464 bfd_boolean add_symbol)
3465 {
3466 int relax_fp_as_gp;
3467 struct elf_nds32_link_hash_table *table;
3468 struct bfd_link_hash_entry *h, *h2;
3469 long unsigned int total = 0;
3470 asection *first = NULL, *final = NULL, *temp;
3471 bfd_vma sda_base = 0;
3472
3473 h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
3474 if (!h || (h->type != bfd_link_hash_defined
3475 && h->type != bfd_link_hash_defweak))
3476 {
3477 /* The first section must be 4-byte aligned to promise _SDA_BASE_ being
3478 4 byte-aligned. Therefore, it has to set the first section ".data"
3479 4 byte-aligned. */
3480 static const char sec_name[SDA_SECTION_NUM][10] =
3481 {
3482 ".data", ".got", ".sdata_d", ".sdata_w", ".sdata_h", ".sdata_b",
3483 ".sbss_b", ".sbss_h", ".sbss_w", ".sbss_d"
3484 };
3485 size_t i = 0;
3486
3487 if (output_bfd->sections == NULL)
3488 {
3489 *psb = elf_gp (output_bfd);
3490 return bfd_reloc_ok;
3491 }
3492
3493 /* Get the first and final section. */
3494 while (i < ARRAY_SIZE (sec_name))
3495 {
3496 temp = bfd_get_section_by_name (output_bfd, sec_name[i]);
3497 if (temp && !first && (temp->size != 0 || temp->rawsize != 0))
3498 first = temp;
3499 if (temp && (temp->size != 0 || temp->rawsize != 0))
3500 final = temp;
3501
3502 /* Summarize the sections in order to check if joining .bss. */
3503 if (temp && temp->size != 0)
3504 total += temp->size;
3505 else if (temp && temp->rawsize != 0)
3506 total += temp->rawsize;
3507
3508 i++;
3509 }
3510
3511 /* Check .bss size. */
3512 temp = bfd_get_section_by_name (output_bfd, ".bss");
3513 if (temp)
3514 {
3515 if (temp->size != 0)
3516 total += temp->size;
3517 else if (temp->rawsize != 0)
3518 total += temp->rawsize;
3519
3520 if (total < 0x80000)
3521 {
3522 if (!first && (temp->size != 0 || temp->rawsize != 0))
3523 first = temp;
3524 if ((temp->size != 0 || temp->rawsize != 0))
3525 final = temp;
3526 }
3527 }
3528
3529 if (first && final)
3530 {
3531 /* The middle of data region. */
3532 sda_base = final->vma / 2 + final->rawsize / 2 + first->vma / 2;
3533
3534 /* Find the section sda_base located. */
3535 i = 0;
3536 while (i < ARRAY_SIZE (sec_name))
3537 {
3538 final = bfd_get_section_by_name (output_bfd, sec_name[i]);
3539 if (final && (final->size != 0 || final->rawsize != 0)
3540 && sda_base >= final->vma)
3541 {
3542 first = final;
3543 i++;
3544 }
3545 else
3546 break;
3547 }
3548 }
3549 else
3550 {
3551 /* If there is not any default data section in output bfd, try to find
3552 the first data section. If no data section be found, just simplily
3553 choose the first output section. */
3554 temp = output_bfd->sections;
3555 while (temp)
3556 {
3557 if (temp->flags & SEC_ALLOC
3558 && (((temp->flags & SEC_DATA)
3559 && ((temp->flags & SEC_READONLY) == 0))
3560 || (temp->flags & SEC_LOAD) == 0)
3561 && (temp->size != 0 || temp->rawsize != 0))
3562 {
3563 if (!first)
3564 first = temp;
3565 final = temp;
3566 }
3567 temp = temp->next;
3568 }
3569
3570 /* There is no data or bss section. */
3571 if (!first || (first->size == 0 && first->rawsize == 0))
3572 {
3573 first = output_bfd->sections;
3574 while (first && first->size == 0 && first->rawsize == 0)
3575 first = first->next;
3576 }
3577
3578 /* There is no concrete section. */
3579 if (!first)
3580 {
3581 *psb = elf_gp (output_bfd);
3582 return bfd_reloc_ok;
3583 }
3584
3585 if (final && (final->vma + final->rawsize - first->vma) <= 0x4000)
3586 sda_base = final->vma / 2 + final->rawsize / 2 + first->vma / 2;
3587 else
3588 sda_base = first->vma + 0x2000;
3589 }
3590
3591 sda_base -= first->vma;
3592 sda_base = sda_base & (~7);
3593
3594 if (!_bfd_generic_link_add_one_symbol
3595 (info, output_bfd, "_SDA_BASE_", BSF_GLOBAL | BSF_WEAK, first,
3596 (bfd_vma) sda_base, (const char *) NULL, FALSE,
3597 get_elf_backend_data (output_bfd)->collect, &h))
3598 return FALSE;
3599
3600 sda_rela_sec = first;
3601 }
3602
3603 /* Set _FP_BASE_ to _SDA_BASE_. */
3604 table = nds32_elf_hash_table (info);
3605 relax_fp_as_gp = table->relax_fp_as_gp;
3606 h2 = bfd_link_hash_lookup (info->hash, FP_BASE_NAME, FALSE, FALSE, FALSE);
3607 /* _SDA_BASE_ is difined in linker script. */
3608 if (!first)
3609 {
3610 first = h->u.def.section;
3611 sda_base = h->u.def.value;
3612 }
3613
3614 if (relax_fp_as_gp && h2
3615 && (h2->type == bfd_link_hash_undefweak
3616 || h2->type == bfd_link_hash_undefined))
3617 {
3618 /* Define a weak FP_BASE_NAME here to prevent the undefined symbol.
3619 And set FP equal to SDA_BASE to do relaxation for
3620 la $fp, _FP_BASE_. */
3621 if (!_bfd_generic_link_add_one_symbol
3622 (info, output_bfd, FP_BASE_NAME, BSF_GLOBAL | BSF_WEAK,
3623 first, sda_base, (const char *) NULL,
3624 FALSE, get_elf_backend_data (output_bfd)->collect, &h2))
3625 return FALSE;
3626 }
3627
3628 if (add_symbol)
3629 {
3630 if (h)
3631 {
3632 /* Now set gp. */
3633 elf_gp (output_bfd) = (h->u.def.value
3634 + h->u.def.section->output_section->vma
3635 + h->u.def.section->output_offset);
3636 }
3637 else
3638 {
3639 _bfd_error_handler (_("error: can't find symbol: %s"), "_SDA_BASE_");
3640 return bfd_reloc_dangerous;
3641 }
3642 }
3643
3644 *psb = h->u.def.value
3645 + h->u.def.section->output_section->vma
3646 + h->u.def.section->output_offset;
3647 return bfd_reloc_ok;
3648 }
3649 \f
3650
3651 /* Return size of a PLT entry. */
3652 #define elf_nds32_sizeof_plt(info) PLT_ENTRY_SIZE
3653
3654 /* Create an entry in an nds32 ELF linker hash table. */
3655
3656 static struct bfd_hash_entry *
3657 nds32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
3658 struct bfd_hash_table *table,
3659 const char *string)
3660 {
3661 struct elf_nds32_link_hash_entry *ret;
3662
3663 ret = (struct elf_nds32_link_hash_entry *) entry;
3664
3665 /* Allocate the structure if it has not already been allocated by a
3666 subclass. */
3667 if (ret == NULL)
3668 ret = (struct elf_nds32_link_hash_entry *)
3669 bfd_hash_allocate (table, sizeof (struct elf_nds32_link_hash_entry));
3670
3671 if (ret == NULL)
3672 return (struct bfd_hash_entry *) ret;
3673
3674 /* Call the allocation method of the superclass. */
3675 ret = (struct elf_nds32_link_hash_entry *)
3676 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);
3677
3678 if (ret != NULL)
3679 {
3680 struct elf_nds32_link_hash_entry *eh;
3681
3682 eh = (struct elf_nds32_link_hash_entry *) ret;
3683 eh->dyn_relocs = NULL;
3684 eh->tls_type = GOT_UNKNOWN;
3685 eh->offset_to_gp = 0;
3686 }
3687
3688 return (struct bfd_hash_entry *) ret;
3689 }
3690
3691 /* Create an nds32 ELF linker hash table. */
3692
3693 static struct bfd_link_hash_table *
3694 nds32_elf_link_hash_table_create (bfd *abfd)
3695 {
3696 struct elf_nds32_link_hash_table *ret;
3697
3698 bfd_size_type amt = sizeof (struct elf_nds32_link_hash_table);
3699
3700 ret = (struct elf_nds32_link_hash_table *) bfd_zmalloc (amt);
3701 if (ret == NULL)
3702 return NULL;
3703
3704 /* Patch tag. */
3705 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3706 nds32_elf_link_hash_newfunc,
3707 sizeof (struct elf_nds32_link_hash_entry),
3708 NDS32_ELF_DATA))
3709 {
3710 free (ret);
3711 return NULL;
3712 }
3713
3714 ret->sdynbss = NULL;
3715 ret->srelbss = NULL;
3716 ret->sym_ld_script = NULL;
3717
3718 return &ret->root.root;
3719 }
3720
3721 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
3722 shortcuts to them in our hash table. */
3723
3724 static bfd_boolean
3725 create_got_section (bfd *dynobj, struct bfd_link_info *info)
3726 {
3727 struct elf_link_hash_table *ehtab;
3728
3729 if (!_bfd_elf_create_got_section (dynobj, info))
3730 return FALSE;
3731
3732 ehtab = elf_hash_table (info);
3733 ehtab->sgot = bfd_get_section_by_name (dynobj, ".got");
3734 ehtab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
3735 if (!ehtab->sgot || !ehtab->sgotplt)
3736 abort ();
3737
3738 /* _bfd_elf_create_got_section will create it for us. */
3739 ehtab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3740 if (ehtab->srelgot == NULL
3741 || !bfd_set_section_flags (dynobj, ehtab->srelgot,
3742 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
3743 | SEC_IN_MEMORY | SEC_LINKER_CREATED
3744 | SEC_READONLY))
3745 || !bfd_set_section_alignment (dynobj, ehtab->srelgot, 2))
3746 return FALSE;
3747
3748 return TRUE;
3749 }
3750
3751 /* Create dynamic sections when linking against a dynamic object. */
3752
3753 static bfd_boolean
3754 nds32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3755 {
3756 struct elf_link_hash_table *ehtab;
3757 struct elf_nds32_link_hash_table *htab;
3758 flagword flags, pltflags;
3759 register asection *s;
3760 const struct elf_backend_data *bed;
3761 int ptralign = 2; /* 32-bit */
3762 const char *secname;
3763 char *relname;
3764 flagword secflags;
3765 asection *sec;
3766
3767 bed = get_elf_backend_data (abfd);
3768 ehtab = elf_hash_table (info);
3769 htab = nds32_elf_hash_table (info);
3770
3771 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3772 .rel[a].bss sections. */
3773
3774 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3775 | SEC_LINKER_CREATED);
3776
3777 pltflags = flags;
3778 pltflags |= SEC_CODE;
3779 if (bed->plt_not_loaded)
3780 pltflags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
3781 if (bed->plt_readonly)
3782 pltflags |= SEC_READONLY;
3783
3784 s = bfd_make_section (abfd, ".plt");
3785 ehtab->splt = s;
3786 if (s == NULL
3787 || !bfd_set_section_flags (abfd, s, pltflags)
3788 || !bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3789 return FALSE;
3790
3791 if (bed->want_plt_sym)
3792 {
3793 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3794 .plt section. */
3795 struct bfd_link_hash_entry *bh = NULL;
3796 struct elf_link_hash_entry *h;
3797
3798 if (!(_bfd_generic_link_add_one_symbol
3799 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3800 (bfd_vma) 0, (const char *) NULL, FALSE,
3801 get_elf_backend_data (abfd)->collect, &bh)))
3802 return FALSE;
3803
3804 h = (struct elf_link_hash_entry *) bh;
3805 h->def_regular = 1;
3806 h->type = STT_OBJECT;
3807
3808 if (bfd_link_pic (info) && !bfd_elf_link_record_dynamic_symbol (info, h))
3809 return FALSE;
3810 }
3811
3812 s = bfd_make_section (abfd,
3813 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
3814 ehtab->srelplt = s;
3815 if (s == NULL
3816 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3817 || !bfd_set_section_alignment (abfd, s, ptralign))
3818 return FALSE;
3819
3820 if (ehtab->sgot == NULL && !create_got_section (abfd, info))
3821 return FALSE;
3822
3823 for (sec = abfd->sections; sec; sec = sec->next)
3824 {
3825 secflags = bfd_get_section_flags (abfd, sec);
3826 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3827 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3828 continue;
3829 secname = bfd_get_section_name (abfd, sec);
3830 relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
3831 strcpy (relname, ".rela");
3832 strcat (relname, secname);
3833 if (bfd_get_section_by_name (abfd, secname))
3834 continue;
3835 s = bfd_make_section (abfd, relname);
3836 if (s == NULL
3837 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3838 || !bfd_set_section_alignment (abfd, s, ptralign))
3839 return FALSE;
3840 }
3841
3842 if (bed->want_dynbss)
3843 {
3844 /* The .dynbss section is a place to put symbols which are defined
3845 by dynamic objects, are referenced by regular objects, and are
3846 not functions. We must allocate space for them in the process
3847 image and use a R_*_COPY reloc to tell the dynamic linker to
3848 initialize them at run time. The linker script puts the .dynbss
3849 section into the .bss section of the final image. */
3850 s = bfd_make_section (abfd, ".dynbss");
3851 htab->sdynbss = s;
3852 if (s == NULL
3853 || !bfd_set_section_flags (abfd, s, SEC_ALLOC | SEC_LINKER_CREATED))
3854 return FALSE;
3855 /* The .rel[a].bss section holds copy relocs. This section is not
3856 normally needed. We need to create it here, though, so that the
3857 linker will map it to an output section. We can't just create it
3858 only if we need it, because we will not know whether we need it
3859 until we have seen all the input files, and the first time the
3860 main linker code calls BFD after examining all the input files
3861 (size_dynamic_sections) the input sections have already been
3862 mapped to the output sections. If the section turns out not to
3863 be needed, we can discard it later. We will never need this
3864 section when generating a shared object, since they do not use
3865 copy relocs. */
3866 if (!bfd_link_pic (info))
3867 {
3868 s = bfd_make_section (abfd, (bed->default_use_rela_p
3869 ? ".rela.bss" : ".rel.bss"));
3870 htab->srelbss = s;
3871 if (s == NULL
3872 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3873 || !bfd_set_section_alignment (abfd, s, ptralign))
3874 return FALSE;
3875 }
3876 }
3877
3878 return TRUE;
3879 }
3880
3881 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3882 static void
3883 nds32_elf_copy_indirect_symbol (struct bfd_link_info *info,
3884 struct elf_link_hash_entry *dir,
3885 struct elf_link_hash_entry *ind)
3886 {
3887 struct elf_nds32_link_hash_entry *edir, *eind;
3888
3889 edir = (struct elf_nds32_link_hash_entry *) dir;
3890 eind = (struct elf_nds32_link_hash_entry *) ind;
3891
3892 if (eind->dyn_relocs != NULL)
3893 {
3894 if (edir->dyn_relocs != NULL)
3895 {
3896 struct elf_dyn_relocs **pp;
3897 struct elf_dyn_relocs *p;
3898
3899 if (ind->root.type == bfd_link_hash_indirect)
3900 abort ();
3901
3902 /* Add reloc counts against the weak sym to the strong sym
3903 list. Merge any entries against the same section. */
3904 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
3905 {
3906 struct elf_dyn_relocs *q;
3907
3908 for (q = edir->dyn_relocs; q != NULL; q = q->next)
3909 if (q->sec == p->sec)
3910 {
3911 q->pc_count += p->pc_count;
3912 q->count += p->count;
3913 *pp = p->next;
3914 break;
3915 }
3916 if (q == NULL)
3917 pp = &p->next;
3918 }
3919 *pp = edir->dyn_relocs;
3920 }
3921
3922 edir->dyn_relocs = eind->dyn_relocs;
3923 eind->dyn_relocs = NULL;
3924 }
3925
3926 if (ind->root.type == bfd_link_hash_indirect)
3927 {
3928 if (dir->got.refcount <= 0)
3929 {
3930 edir->tls_type = eind->tls_type;
3931 eind->tls_type = GOT_UNKNOWN;
3932 }
3933 }
3934
3935 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3936 }
3937 \f
3938
3939 /* Find dynamic relocs for H that apply to read-only sections. */
3940
3941 static asection *
3942 readonly_dynrelocs (struct elf_link_hash_entry *h)
3943 {
3944 struct elf_dyn_relocs *p;
3945
3946 for (p = elf32_nds32_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
3947 {
3948 asection *s = p->sec->output_section;
3949
3950 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3951 return p->sec;
3952 }
3953 return NULL;
3954 }
3955
3956 /* Adjust a symbol defined by a dynamic object and referenced by a
3957 regular object. The current definition is in some section of the
3958 dynamic object, but we're not including those sections. We have to
3959 change the definition to something the rest of the link can
3960 understand. */
3961
3962 static bfd_boolean
3963 nds32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
3964 struct elf_link_hash_entry *h)
3965 {
3966 struct elf_nds32_link_hash_table *htab;
3967 bfd *dynobj;
3968 asection *s;
3969 unsigned int power_of_two;
3970
3971 dynobj = elf_hash_table (info)->dynobj;
3972
3973 /* Make sure we know what is going on here. */
3974 BFD_ASSERT (dynobj != NULL
3975 && (h->needs_plt
3976 || h->is_weakalias
3977 || (h->def_dynamic && h->ref_regular && !h->def_regular)));
3978
3979
3980 /* If this is a function, put it in the procedure linkage table. We
3981 will fill in the contents of the procedure linkage table later,
3982 when we know the address of the .got section. */
3983 if (h->type == STT_FUNC || h->needs_plt)
3984 {
3985 if (!bfd_link_pic (info)
3986 && !h->def_dynamic
3987 && !h->ref_dynamic
3988 && h->root.type != bfd_link_hash_undefweak
3989 && h->root.type != bfd_link_hash_undefined)
3990 {
3991 /* This case can occur if we saw a PLT reloc in an input
3992 file, but the symbol was never referred to by a dynamic
3993 object. In such a case, we don't actually need to build
3994 a procedure linkage table, and we can just do a PCREL
3995 reloc instead. */
3996 h->plt.offset = (bfd_vma) - 1;
3997 h->needs_plt = 0;
3998 }
3999
4000 return TRUE;
4001 }
4002 else
4003 h->plt.offset = (bfd_vma) - 1;
4004
4005 /* If this is a weak symbol, and there is a real definition, the
4006 processor independent code will have arranged for us to see the
4007 real definition first, and we can just use the same value. */
4008 if (h->is_weakalias)
4009 {
4010 struct elf_link_hash_entry *def = weakdef (h);
4011 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
4012 h->root.u.def.section = def->root.u.def.section;
4013 h->root.u.def.value = def->root.u.def.value;
4014 return TRUE;
4015 }
4016
4017 /* This is a reference to a symbol defined by a dynamic object which
4018 is not a function. */
4019
4020 /* If we are creating a shared library, we must presume that the
4021 only references to the symbol are via the global offset table.
4022 For such cases we need not do anything here; the relocations will
4023 be handled correctly by relocate_section. */
4024 if (bfd_link_pic (info))
4025 return TRUE;
4026
4027 /* If there are no references to this symbol that do not use the
4028 GOT, we don't need to generate a copy reloc. */
4029 if (!h->non_got_ref)
4030 return TRUE;
4031
4032 /* If -z nocopyreloc was given, we won't generate them either. */
4033 if (0 && info->nocopyreloc)
4034 {
4035 h->non_got_ref = 0;
4036 return TRUE;
4037 }
4038
4039 /* If we don't find any dynamic relocs in read-only sections, then
4040 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
4041 if (!readonly_dynrelocs (h))
4042 {
4043 h->non_got_ref = 0;
4044 return TRUE;
4045 }
4046
4047 /* We must allocate the symbol in our .dynbss section, which will
4048 become part of the .bss section of the executable. There will be
4049 an entry for this symbol in the .dynsym section. The dynamic
4050 object will contain position independent code, so all references
4051 from the dynamic object to this symbol will go through the global
4052 offset table. The dynamic linker will use the .dynsym entry to
4053 determine the address it must put in the global offset table, so
4054 both the dynamic object and the regular object will refer to the
4055 same memory location for the variable. */
4056
4057 htab = nds32_elf_hash_table (info);
4058 s = htab->sdynbss;
4059 BFD_ASSERT (s != NULL);
4060
4061 /* We must generate a R_NDS32_COPY reloc to tell the dynamic linker
4062 to copy the initial value out of the dynamic object and into the
4063 runtime process image. We need to remember the offset into the
4064 .rela.bss section we are going to use. */
4065 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4066 {
4067 asection *srel;
4068
4069 srel = htab->srelbss;
4070 BFD_ASSERT (srel != NULL);
4071 srel->size += sizeof (Elf32_External_Rela);
4072 h->needs_copy = 1;
4073 }
4074
4075 /* We need to figure out the alignment required for this symbol. I
4076 have no idea how ELF linkers handle this. */
4077 power_of_two = bfd_log2 (h->size);
4078 if (power_of_two > 3)
4079 power_of_two = 3;
4080
4081 /* Apply the required alignment. */
4082 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
4083 if (power_of_two > bfd_get_section_alignment (dynobj, s))
4084 {
4085 if (!bfd_set_section_alignment (dynobj, s, power_of_two))
4086 return FALSE;
4087 }
4088
4089 /* Define the symbol as being at this point in the section. */
4090 h->root.u.def.section = s;
4091 h->root.u.def.value = s->size;
4092
4093 /* Increment the section size to make room for the symbol. */
4094 s->size += h->size;
4095
4096 return TRUE;
4097 }
4098
4099 /* Allocate space in .plt, .got and associated reloc sections for
4100 dynamic relocs. */
4101
4102 static bfd_boolean
4103 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
4104 {
4105 struct bfd_link_info *info;
4106 struct elf_link_hash_table *ehtab;
4107 struct elf_nds32_link_hash_table *htab;
4108 struct elf_nds32_link_hash_entry *eh;
4109 struct elf_dyn_relocs *p;
4110
4111 if (h->root.type == bfd_link_hash_indirect)
4112 return TRUE;
4113
4114 /* When warning symbols are created, they **replace** the "real"
4115 entry in the hash table, thus we never get to see the real
4116 symbol in a hash traversal. So look at it now. */
4117 if (h->root.type == bfd_link_hash_warning)
4118 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4119
4120 eh = (struct elf_nds32_link_hash_entry *) h;
4121
4122 info = (struct bfd_link_info *) inf;
4123 ehtab = elf_hash_table (info);
4124 htab = nds32_elf_hash_table (info);
4125 if (htab == NULL)
4126 return FALSE;
4127
4128 eh = (struct elf_nds32_link_hash_entry *) h;
4129
4130 if ((htab->root.dynamic_sections_created || h->type == STT_GNU_IFUNC)
4131 && h->plt.refcount > 0
4132 && !(bfd_link_pie (info) && h->def_regular))
4133 {
4134 /* Make sure this symbol is output as a dynamic symbol.
4135 Undefined weak syms won't yet be marked as dynamic. */
4136 if (h->dynindx == -1 && !h->forced_local)
4137 {
4138 if (!bfd_elf_link_record_dynamic_symbol (info, h))
4139 return FALSE;
4140 }
4141
4142 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
4143 {
4144 asection *s = ehtab->splt;
4145
4146 /* If this is the first .plt entry, make room for the special
4147 first entry. */
4148 if (s->size == 0)
4149 s->size += PLT_ENTRY_SIZE;
4150
4151 h->plt.offset = s->size;
4152
4153 /* If this symbol is not defined in a regular file, and we are
4154 not generating a shared library, then set the symbol to this
4155 location in the .plt. This is required to make function
4156 pointers compare as equal between the normal executable and
4157 the shared library. */
4158 if (!bfd_link_pic (info) && !h->def_regular)
4159 {
4160 h->root.u.def.section = s;
4161 h->root.u.def.value = h->plt.offset;
4162 }
4163
4164 /* Make room for this entry. */
4165 s->size += PLT_ENTRY_SIZE;
4166
4167 /* We also need to make an entry in the .got.plt section, which
4168 will be placed in the .got section by the linker script. */
4169 ehtab->sgotplt->size += 4;
4170
4171 /* We also need to make an entry in the .rel.plt section. */
4172 ehtab->srelplt->size += sizeof (Elf32_External_Rela);
4173 if (htab->tls_desc_trampoline)
4174 htab->next_tls_desc_index++;
4175 }
4176 else
4177 {
4178 h->plt.offset = (bfd_vma) - 1;
4179 h->needs_plt = 0;
4180 }
4181 }
4182 else
4183 {
4184 h->plt.offset = (bfd_vma) - 1;
4185 h->needs_plt = 0;
4186 }
4187
4188 if (h->got.refcount > 0)
4189 {
4190 asection *sgot;
4191 bfd_boolean dyn;
4192 int tls_type = elf32_nds32_hash_entry (h)->tls_type;
4193
4194 /* Make sure this symbol is output as a dynamic symbol.
4195 Undefined weak syms won't yet be marked as dynamic. */
4196 if (h->dynindx == -1 && !h->forced_local)
4197 {
4198 if (!bfd_elf_link_record_dynamic_symbol (info, h))
4199 return FALSE;
4200 }
4201
4202 sgot = elf_hash_table (info)->sgot;
4203 h->got.offset = sgot->size;
4204
4205 if (tls_type == GOT_UNKNOWN)
4206 abort ();
4207
4208 /* Non-TLS symbols, and TLS_IE need one GOT slot. */
4209 if (tls_type & (GOT_NORMAL | GOT_TLS_IE | GOT_TLS_IEGP))
4210 sgot->size += 4;
4211 else
4212 {
4213 /* TLS_DESC, TLS_GD, and TLS_LD need 2 consecutive GOT slots. */
4214 if (tls_type & GOT_TLS_DESC)
4215 sgot->size += 8;
4216 }
4217
4218 dyn = htab->root.dynamic_sections_created;
4219
4220 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
4221 {
4222 if (tls_type == GOT_TLS_DESC && htab->tls_desc_trampoline)
4223 {
4224 /* TLS_DESC with trampoline needs a relocation slot
4225 within .rela.plt. */
4226 htab->num_tls_desc++;
4227 ehtab->srelplt->size += sizeof (Elf32_External_Rela);
4228 htab->tls_trampoline = -1;
4229 }
4230 else
4231 {
4232 /* other relocations, including TLS_DESC without trampoline, need
4233 a relocation slot within .rela.got. */
4234 ehtab->srelgot->size += sizeof (Elf32_External_Rela);
4235 }
4236 }
4237 }
4238 else
4239 h->got.offset = (bfd_vma)-1;
4240
4241 if (eh->dyn_relocs == NULL)
4242 return TRUE;
4243
4244 /* In the shared -Bsymbolic case, discard space allocated for
4245 dynamic pc-relative relocs against symbols which turn out to be
4246 defined in regular objects. For the normal shared case, discard
4247 space for pc-relative relocs that have become local due to symbol
4248 visibility changes. */
4249
4250 if (bfd_link_pic (info))
4251 {
4252 if (h->def_regular && (h->forced_local || info->symbolic))
4253 {
4254 struct elf_dyn_relocs **pp;
4255
4256 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
4257 {
4258 p->count -= p->pc_count;
4259 p->pc_count = 0;
4260 if (p->count == 0)
4261 *pp = p->next;
4262 else
4263 pp = &p->next;
4264 }
4265 }
4266 }
4267 else
4268 {
4269 /* For the non-shared case, discard space for relocs against
4270 symbols which turn out to need copy relocs or are not dynamic. */
4271
4272 if (!h->non_got_ref
4273 && ((h->def_dynamic
4274 && !h->def_regular)
4275 || (htab->root.dynamic_sections_created
4276 && (h->root.type == bfd_link_hash_undefweak
4277 || h->root.type == bfd_link_hash_undefined))))
4278 {
4279 /* Make sure this symbol is output as a dynamic symbol.
4280 Undefined weak syms won't yet be marked as dynamic. */
4281 if (h->dynindx == -1 && !h->forced_local)
4282 {
4283 if (!bfd_elf_link_record_dynamic_symbol (info, h))
4284 return FALSE;
4285 }
4286
4287 /* If that succeeded, we know we'll be keeping all the
4288 relocs. */
4289 if (h->dynindx != -1)
4290 goto keep;
4291 }
4292
4293 eh->dyn_relocs = NULL;
4294
4295 keep:;
4296 }
4297
4298 /* Finally, allocate space. */
4299 for (p = eh->dyn_relocs; p != NULL; p = p->next)
4300 {
4301 asection *sreloc = elf_section_data (p->sec)->sreloc;
4302 sreloc->size += p->count * sizeof (Elf32_External_Rela);
4303 }
4304
4305 return TRUE;
4306 }
4307
4308 /* Add relocation REL to the end of relocation section SRELOC. */
4309
4310 static void
4311 elf32_nds32_add_dynreloc (bfd *output_bfd,
4312 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4313 asection *sreloc, Elf_Internal_Rela *rel)
4314 {
4315 bfd_byte *loc;
4316 if (sreloc == NULL)
4317 abort ();
4318
4319 loc = sreloc->contents;
4320 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4321 if (sreloc->reloc_count * sizeof (Elf32_External_Rela) > sreloc->size)
4322 abort ();
4323
4324 bfd_elf32_swap_reloca_out (output_bfd, rel, loc);
4325 }
4326
4327 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
4328 read-only sections. */
4329
4330 static bfd_boolean
4331 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
4332 {
4333 asection *sec;
4334
4335 if (h->root.type == bfd_link_hash_indirect)
4336 return TRUE;
4337
4338 sec = readonly_dynrelocs (h);
4339 if (sec != NULL)
4340 {
4341 struct bfd_link_info *info = (struct bfd_link_info *) info_p;
4342
4343 info->flags |= DF_TEXTREL;
4344 info->callbacks->minfo
4345 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
4346 sec->owner, h->root.root.string, sec);
4347
4348 /* Not an error, just cut short the traversal. */
4349 return FALSE;
4350 }
4351 return TRUE;
4352 }
4353
4354 /* Set the sizes of the dynamic sections. */
4355
4356 static bfd_boolean
4357 nds32_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
4358 struct bfd_link_info *info)
4359 {
4360 struct elf_nds32_link_hash_table *htab;
4361 bfd *dynobj;
4362 asection *s;
4363 bfd_boolean relocs;
4364 bfd_boolean plt;
4365 bfd *ibfd;
4366
4367 htab = nds32_elf_hash_table (info);
4368 if (htab == NULL)
4369 return FALSE;
4370
4371 dynobj = elf_hash_table (info)->dynobj;
4372 BFD_ASSERT (dynobj != NULL);
4373
4374 if (elf_hash_table (info)->dynamic_sections_created)
4375 {
4376 /* Set the contents of the .interp section to the interpreter. */
4377 if (bfd_link_executable (info) && !info->nointerp)
4378 {
4379 s = bfd_get_section_by_name (dynobj, ".interp");
4380 BFD_ASSERT (s != NULL);
4381 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
4382 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4383 }
4384 }
4385
4386 /* Set up .got offsets for local syms, and space for local dynamic
4387 relocs. */
4388 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
4389 {
4390 bfd_signed_vma *local_got;
4391 bfd_signed_vma *end_local_got;
4392 bfd_size_type locsymcount;
4393 Elf_Internal_Shdr *symtab_hdr;
4394 asection *sgot;
4395 char *local_tls_type;
4396 unsigned long symndx;
4397 bfd_vma *local_tlsdesc_gotent;
4398
4399 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
4400 continue;
4401
4402 for (s = ibfd->sections; s != NULL; s = s->next)
4403 {
4404 struct elf_dyn_relocs *p;
4405
4406 for (p = ((struct elf_dyn_relocs *)
4407 elf_section_data (s)->local_dynrel);
4408 p != NULL; p = p->next)
4409 {
4410 if (!bfd_is_abs_section (p->sec)
4411 && bfd_is_abs_section (p->sec->output_section))
4412 {
4413 /* Input section has been discarded, either because
4414 it is a copy of a linkonce section or due to
4415 linker script /DISCARD/, so we'll be discarding
4416 the relocs too. */
4417 }
4418 else if (p->count != 0)
4419 {
4420 asection *sreloc = elf_section_data (p->sec)->sreloc;
4421 sreloc->size += p->count * sizeof (Elf32_External_Rela);
4422 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
4423 info->flags |= DF_TEXTREL;
4424 }
4425 }
4426 }
4427
4428 local_got = elf_local_got_refcounts (ibfd);
4429 if (!local_got)
4430 continue;
4431
4432 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4433 locsymcount = symtab_hdr->sh_info;
4434 end_local_got = local_got + locsymcount;
4435 sgot = elf_hash_table (info)->sgot;
4436 local_tls_type = elf32_nds32_local_got_tls_type (ibfd);
4437 local_tlsdesc_gotent = elf32_nds32_local_tlsdesc_gotent (ibfd);
4438 for (symndx = 0; local_got < end_local_got;
4439 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent, ++symndx)
4440 {
4441 if (*local_got > 0)
4442 {
4443 int num_of_got_entry_needed = 0;
4444 *local_got = sgot->size;
4445 *local_tlsdesc_gotent = sgot->size;
4446
4447 /* TLS_NORMAL, and TLS_IE need one slot in .got. */
4448 if (*local_tls_type & (GOT_NORMAL | GOT_TLS_IE | GOT_TLS_IEGP))
4449 num_of_got_entry_needed = 1;
4450 /* TLS_GD, TLS_LD, and TLS_DESC need an 8-byte structure in the GOT. */
4451 else if (*local_tls_type & GOT_TLS_DESC)
4452 num_of_got_entry_needed = 2;
4453
4454 sgot->size += (num_of_got_entry_needed << 2);
4455
4456 /* non-relax-able TLS_DESCs need a slot in .rela.plt.
4457 others need a slot in .rela.got. */
4458 if (*local_tls_type == GOT_TLS_DESC)
4459 {
4460 if (bfd_link_pic (info))
4461 {
4462 if (htab->tls_desc_trampoline)
4463 {
4464 htab->num_tls_desc++;
4465 htab->root.srelplt->size += sizeof (Elf32_External_Rela);
4466 htab->tls_trampoline = -1;
4467 }
4468 else
4469 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
4470 }
4471 else
4472 {
4473 /* TLS_DESC -> TLS_LE */
4474 }
4475 }
4476 else
4477 {
4478 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
4479 }
4480 }
4481 else
4482 {
4483 *local_got = (bfd_vma) -1;
4484 *local_tlsdesc_gotent = (bfd_vma) -1;
4485 }
4486 }
4487 }
4488
4489 /* Allocate global sym .plt and .got entries, and space for global
4490 sym dynamic relocs. */
4491 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (void *) info);
4492
4493 /* For every jump slot reserved in the sgotplt, reloc_count is
4494 incremented. However, when we reserve space for TLS descriptors,
4495 it's not incremented, so in order to compute the space reserved
4496 for them, it suffices to multiply the reloc count by the jump
4497 slot size. */
4498 if (htab->tls_desc_trampoline && htab->root.srelplt)
4499 htab->sgotplt_jump_table_size = elf32_nds32_compute_jump_table_size (htab);
4500
4501 if (htab->tls_trampoline)
4502 {
4503 htab->tls_trampoline = htab->root.splt->size;
4504
4505 /* If we're not using lazy TLS relocations, don't generate the
4506 PLT and GOT entries they require. */
4507 if (!(info->flags & DF_BIND_NOW))
4508 {
4509 htab->dt_tlsdesc_got = htab->root.sgot->size;
4510 htab->root.sgot->size += 4;
4511
4512 htab->dt_tlsdesc_plt = htab->root.splt->size;
4513 htab->root.splt->size += 4 * ARRAY_SIZE (dl_tlsdesc_lazy_trampoline);
4514 }
4515 }
4516
4517 /* We now have determined the sizes of the various dynamic sections.
4518 Allocate memory for them. */
4519 /* The check_relocs and adjust_dynamic_symbol entry points have
4520 determined the sizes of the various dynamic sections. Allocate
4521 memory for them. */
4522 plt = FALSE;
4523 relocs = FALSE;
4524 for (s = dynobj->sections; s != NULL; s = s->next)
4525 {
4526 if ((s->flags & SEC_LINKER_CREATED) == 0)
4527 continue;
4528
4529 if (s == htab->root.splt)
4530 {
4531 /* Strip this section if we don't need it; see the
4532 comment below. */
4533 plt = s->size != 0;
4534 }
4535 else if (s == elf_hash_table (info)->sgot)
4536 {
4537 got_size += s->size;
4538 }
4539 else if (s == elf_hash_table (info)->sgotplt)
4540 {
4541 got_size += s->size;
4542 }
4543 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
4544 {
4545 if (s->size != 0 && s != elf_hash_table (info)->srelplt)
4546 relocs = TRUE;
4547
4548 /* We use the reloc_count field as a counter if we need
4549 to copy relocs into the output file. */
4550 s->reloc_count = 0;
4551 }
4552 else
4553 {
4554 /* It's not one of our sections, so don't allocate space. */
4555 continue;
4556 }
4557
4558 if (s->size == 0)
4559 {
4560 /* If we don't need this section, strip it from the
4561 output file. This is mostly to handle .rela.bss and
4562 .rela.plt. We must create both sections in
4563 create_dynamic_sections, because they must be created
4564 before the linker maps input sections to output
4565 sections. The linker does that before
4566 adjust_dynamic_symbol is called, and it is that
4567 function which decides whether anything needs to go
4568 into these sections. */
4569 s->flags |= SEC_EXCLUDE;
4570 continue;
4571 }
4572
4573 /* Allocate memory for the section contents. We use bfd_zalloc
4574 here in case unused entries are not reclaimed before the
4575 section's contents are written out. This should not happen,
4576 but this way if it does, we get a R_NDS32_NONE reloc instead
4577 of garbage. */
4578 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
4579 if (s->contents == NULL)
4580 return FALSE;
4581 }
4582
4583
4584 if (htab->root.dynamic_sections_created)
4585 {
4586 /* Add some entries to the .dynamic section. We fill in the
4587 values later, in nds32_elf_finish_dynamic_sections, but we
4588 must add the entries now so that we get the correct size for
4589 the .dynamic section. The DT_DEBUG entry is filled in by the
4590 dynamic linker and used by the debugger. */
4591 #define add_dynamic_entry(TAG, VAL) \
4592 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4593
4594 if (bfd_link_executable (info))
4595 {
4596 if (!add_dynamic_entry (DT_DEBUG, 0))
4597 return FALSE;
4598 }
4599
4600 if (elf_hash_table (info)->splt->size != 0)
4601 {
4602 if (!add_dynamic_entry (DT_PLTGOT, 0)
4603 || !add_dynamic_entry (DT_PLTRELSZ, 0)
4604 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
4605 || !add_dynamic_entry (DT_JMPREL, 0))
4606 return FALSE;
4607 }
4608
4609 if (htab->tls_desc_trampoline && plt)
4610 {
4611 if (htab->dt_tlsdesc_plt
4612 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
4613 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
4614 return FALSE;
4615 }
4616
4617 if (relocs)
4618 {
4619 if (!add_dynamic_entry (DT_RELA, 0)
4620 || !add_dynamic_entry (DT_RELASZ, 0)
4621 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
4622 return FALSE;
4623
4624 /* If any dynamic relocs apply to a read-only section,
4625 then we need a DT_TEXTREL entry. */
4626 if ((info->flags & DF_TEXTREL) == 0)
4627 elf_link_hash_traverse (&htab->root, maybe_set_textrel,
4628 (void *) info);
4629
4630 if ((info->flags & DF_TEXTREL) != 0)
4631 {
4632 if (!add_dynamic_entry (DT_TEXTREL, 0))
4633 return FALSE;
4634 }
4635 }
4636 }
4637 #undef add_dynamic_entry
4638
4639 return TRUE;
4640 }
4641
4642 static bfd_reloc_status_type
4643 nds32_relocate_contents (reloc_howto_type *howto, bfd *input_bfd,
4644 bfd_vma relocation, bfd_byte *location)
4645 {
4646 int size;
4647 bfd_vma x = 0;
4648 bfd_reloc_status_type flag;
4649 unsigned int rightshift = howto->rightshift;
4650 unsigned int bitpos = howto->bitpos;
4651
4652 /* If the size is negative, negate RELOCATION. This isn't very
4653 general. */
4654 if (howto->size < 0)
4655 relocation = -relocation;
4656
4657 /* Get the value we are going to relocate. */
4658 size = bfd_get_reloc_size (howto);
4659 switch (size)
4660 {
4661 default:
4662 abort ();
4663 break;
4664 case 0:
4665 return bfd_reloc_ok;
4666 case 2:
4667 x = bfd_getb16 (location);
4668 break;
4669 case 4:
4670 x = bfd_getb32 (location);
4671 break;
4672 }
4673
4674 /* Check for overflow. FIXME: We may drop bits during the addition
4675 which we don't check for. We must either check at every single
4676 operation, which would be tedious, or we must do the computations
4677 in a type larger than bfd_vma, which would be inefficient. */
4678 flag = bfd_reloc_ok;
4679 if (howto->complain_on_overflow != complain_overflow_dont)
4680 {
4681 bfd_vma addrmask, fieldmask, signmask, ss;
4682 bfd_vma a, b, sum;
4683
4684 /* Get the values to be added together. For signed and unsigned
4685 relocations, we assume that all values should be truncated to
4686 the size of an address. For bitfields, all the bits matter.
4687 See also bfd_check_overflow. */
4688 fieldmask = N_ONES (howto->bitsize);
4689 signmask = ~fieldmask;
4690 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
4691 a = (relocation & addrmask) >> rightshift;
4692 b = (x & howto->src_mask & addrmask) >> bitpos;
4693
4694 switch (howto->complain_on_overflow)
4695 {
4696 case complain_overflow_signed:
4697 /* If any sign bits are set, all sign bits must be set.
4698 That is, A must be a valid negative address after
4699 shifting. */
4700 signmask = ~(fieldmask >> 1);
4701 /* Fall through. */
4702
4703 case complain_overflow_bitfield:
4704 /* Much like the signed check, but for a field one bit
4705 wider. We allow a bitfield to represent numbers in the
4706 range -2**n to 2**n-1, where n is the number of bits in the
4707 field. Note that when bfd_vma is 32 bits, a 32-bit reloc
4708 can't overflow, which is exactly what we want. */
4709 ss = a & signmask;
4710 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
4711 flag = bfd_reloc_overflow;
4712
4713 /* We only need this next bit of code if the sign bit of B
4714 is below the sign bit of A. This would only happen if
4715 SRC_MASK had fewer bits than BITSIZE. Note that if
4716 SRC_MASK has more bits than BITSIZE, we can get into
4717 trouble; we would need to verify that B is in range, as
4718 we do for A above. */
4719 ss = ((~howto->src_mask) >> 1) & howto->src_mask;
4720 ss >>= bitpos;
4721
4722 /* Set all the bits above the sign bit. */
4723 b = (b ^ ss) - ss;
4724
4725 /* Now we can do the addition. */
4726 sum = a + b;
4727
4728 /* See if the result has the correct sign. Bits above the
4729 sign bit are junk now; ignore them. If the sum is
4730 positive, make sure we did not have all negative inputs;
4731 if the sum is negative, make sure we did not have all
4732 positive inputs. The test below looks only at the sign
4733 bits, and it really just
4734 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
4735
4736 We mask with addrmask here to explicitly allow an address
4737 wrap-around. The Linux kernel relies on it, and it is
4738 the only way to write assembler code which can run when
4739 loaded at a location 0x80000000 away from the location at
4740 which it is linked. */
4741 if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
4742 flag = bfd_reloc_overflow;
4743
4744 break;
4745
4746 case complain_overflow_unsigned:
4747 /* Checking for an unsigned overflow is relatively easy:
4748 trim the addresses and add, and trim the result as well.
4749 Overflow is normally indicated when the result does not
4750 fit in the field. However, we also need to consider the
4751 case when, e.g., fieldmask is 0x7fffffff or smaller, an
4752 input is 0x80000000, and bfd_vma is only 32 bits; then we
4753 will get sum == 0, but there is an overflow, since the
4754 inputs did not fit in the field. Instead of doing a
4755 separate test, we can check for this by or-ing in the
4756 operands when testing for the sum overflowing its final
4757 field. */
4758 sum = (a + b) & addrmask;
4759 if ((a | b | sum) & signmask)
4760 flag = bfd_reloc_overflow;
4761 break;
4762
4763 default:
4764 abort ();
4765 }
4766 }
4767
4768 /* Put RELOCATION in the right bits. */
4769 relocation >>= (bfd_vma) rightshift;
4770 relocation <<= (bfd_vma) bitpos;
4771
4772 /* Add RELOCATION to the right bits of X. */
4773 /* FIXME : 090616
4774 Because the relaxation may generate duplicate relocation at one address,
4775 an addition to immediate in the instruction may cause the relocation added
4776 several times.
4777 This bug should be fixed in assembler, but a check is also needed here. */
4778 if (howto->partial_inplace)
4779 x = ((x & ~howto->dst_mask)
4780 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
4781 else
4782 x = ((x & ~howto->dst_mask) | ((relocation) & howto->dst_mask));
4783
4784
4785 /* Put the relocated value back in the object file. */
4786 switch (size)
4787 {
4788 default:
4789 case 0:
4790 case 1:
4791 case 8:
4792 abort ();
4793 break;
4794 case 2:
4795 bfd_putb16 (x, location);
4796 break;
4797 case 4:
4798 bfd_putb32 (x, location);
4799 break;
4800 }
4801
4802 return flag;
4803 }
4804
4805 static bfd_reloc_status_type
4806 nds32_elf_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd,
4807 asection *input_section, bfd_byte *contents,
4808 bfd_vma address, bfd_vma value, bfd_vma addend)
4809 {
4810 bfd_vma relocation;
4811
4812 /* Sanity check the address. */
4813 if (address > bfd_get_section_limit (input_bfd, input_section))
4814 return bfd_reloc_outofrange;
4815
4816 /* This function assumes that we are dealing with a basic relocation
4817 against a symbol. We want to compute the value of the symbol to
4818 relocate to. This is just VALUE, the value of the symbol, plus
4819 ADDEND, any addend associated with the reloc. */
4820 relocation = value + addend;
4821
4822 /* If the relocation is PC relative, we want to set RELOCATION to
4823 the distance between the symbol (currently in RELOCATION) and the
4824 location we are relocating. If pcrel_offset is FALSE we do not
4825 need to subtract out the offset of the location within the
4826 section (which is just ADDRESS). */
4827 if (howto->pc_relative)
4828 {
4829 relocation -= (input_section->output_section->vma
4830 + input_section->output_offset);
4831 if (howto->pcrel_offset)
4832 relocation -= address;
4833 }
4834
4835 return nds32_relocate_contents (howto, input_bfd, relocation,
4836 contents + address);
4837 }
4838
4839 static bfd_boolean
4840 nds32_elf_output_symbol_hook (struct bfd_link_info *info,
4841 const char *name,
4842 Elf_Internal_Sym *elfsym ATTRIBUTE_UNUSED,
4843 asection *input_sec,
4844 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4845 {
4846 const char *source;
4847 FILE *sym_ld_script = NULL;
4848 struct elf_nds32_link_hash_table *table;
4849
4850 table = nds32_elf_hash_table (info);
4851 sym_ld_script = table->sym_ld_script;
4852 if (!sym_ld_script)
4853 return TRUE;
4854
4855 if (!h || !name || *name == '\0')
4856 return TRUE;
4857
4858 if (input_sec->flags & SEC_EXCLUDE)
4859 return TRUE;
4860
4861 if (!check_start_export_sym)
4862 {
4863 fprintf (sym_ld_script, "SECTIONS\n{\n");
4864 check_start_export_sym = 1;
4865 }
4866
4867 if (h->root.type == bfd_link_hash_defined
4868 || h->root.type == bfd_link_hash_defweak)
4869 {
4870 if (!h->root.u.def.section->output_section)
4871 return TRUE;
4872
4873 if (bfd_is_const_section (input_sec))
4874 source = input_sec->name;
4875 else
4876 source = input_sec->owner->filename;
4877
4878 fprintf (sym_ld_script, "\t%s = 0x%08lx;\t /* %s */\n",
4879 h->root.root.string,
4880 (long) (h->root.u.def.value
4881 + h->root.u.def.section->output_section->vma
4882 + h->root.u.def.section->output_offset), source);
4883 }
4884
4885 return TRUE;
4886 }
4887
4888 /* Relocate an NDS32/D ELF section.
4889 There is some attempt to make this function usable for many architectures,
4890 both for RELA and REL type relocs, if only to serve as a learning tool.
4891
4892 The RELOCATE_SECTION function is called by the new ELF backend linker
4893 to handle the relocations for a section.
4894
4895 The relocs are always passed as Rela structures; if the section
4896 actually uses Rel structures, the r_addend field will always be
4897 zero.
4898
4899 This function is responsible for adjust the section contents as
4900 necessary, and (if using Rela relocs and generating a
4901 relocatable output file) adjusting the reloc addend as
4902 necessary.
4903
4904 This function does not have to worry about setting the reloc
4905 address or the reloc symbol index.
4906
4907 LOCAL_SYMS is a pointer to the swapped in local symbols.
4908
4909 LOCAL_SECTIONS is an array giving the section in the input file
4910 corresponding to the st_shndx field of each local symbol.
4911
4912 The global hash table entry for the global symbols can be found
4913 via elf_sym_hashes (input_bfd).
4914
4915 When generating relocatable output, this function must handle
4916 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
4917 going to be the section symbol corresponding to the output
4918 section, which means that the addend must be adjusted
4919 accordingly. */
4920
4921 /* Return the base VMA address which should be subtracted from real addresses
4922 when resolving @dtpoff relocation.
4923 This is PT_TLS segment p_vaddr. */
4924
4925 /* Return the relocation value for @tpoff relocation
4926 if STT_TLS virtual address is ADDRESS. */
4927
4928 /* Return the relocation value for @gottpoff relocation
4929 if STT_TLS virtual address is ADDRESS. */
4930
4931 static bfd_vma
4932 gottpoff (struct bfd_link_info *info, bfd_vma address)
4933 {
4934 bfd_vma tp_base;
4935 bfd_vma tp_offset;
4936
4937 /* If tls_sec is NULL, we should have signalled an error already. */
4938 if (elf_hash_table (info)->tls_sec == NULL)
4939 return 0;
4940
4941 tp_base = elf_hash_table (info)->tls_sec->vma;
4942 tp_offset = address - tp_base;
4943
4944 return tp_offset;
4945 }
4946
4947 static bfd_boolean
4948 patch_tls_desc_to_ie (bfd_byte *contents, Elf_Internal_Rela *rel, bfd *ibfd)
4949 {
4950 /* TLS_GD/TLS_LD model #1
4951 46 00 00 00 sethi $r0,#0x0
4952 58 00 00 00 ori $r0,$r0,#0x0
4953 40 00 74 00 add $r0,$r0,$gp
4954 04 10 00 00 lwi $r1,[$r0+#0x0]
4955 4b e0 04 01 jral $lp,$r1 */
4956
4957 /* TLS_GD/TLS_LD model #2
4958 46 00 00 00 sethi $r0,#0x0
4959 58 00 00 00 ori $r0,$r0,#0x0
4960 38 10 74 02 lw $r1,[$r0+($gp<<#0x0)]
4961 40 00 74 00 add $r0,$r0,$gp
4962 4b e0 04 01 jral $lp,$r1 */
4963
4964 /* TLS_IE model (non-PIC)
4965 46 00 00 00 sethi $r0,#0x0
4966 04 00 00 00 lwi $r0,[$r0+#0x0]
4967 38 00 64 02 lw $r0,[$r0+($r25<<#0x0)] */
4968
4969 /* TLS_IE model (PIC)
4970 46 00 00 00 sethi $r0,#0x0
4971 58 00 00 00 ori $r0,$r0,#0x0
4972 38 00 74 02 lw $r0,[$r0+($gp<<#0x0)]
4973 38 00 64 02 lw $r0,[$r0+($r25<<#0x0)] */
4974
4975 /* TLS_GD_TO_IE model
4976 46 00 00 00 sethi $r0,#0x0
4977 58 00 00 00 ori $r0,$r0,#0x0
4978 40 00 74 00 add $r0,$rM,$gp
4979 04 00 00 01 lwi $r0,[$r0+#0x4]
4980 40 00 64 00 add $r0,$r0,$r25 */
4981
4982 bfd_boolean rz = FALSE;
4983
4984 typedef struct
4985 {
4986 uint32_t opcode;
4987 uint32_t mask;
4988 } pat_t;
4989
4990 uint32_t patch[3] =
4991 {
4992 0x40007400, /* add $r0,$rM,$gp */
4993 0x04000001, /* lwi $r0,[$r0+#0x4] */
4994 0x40006400, /* add $r0,$r0,$r25 */
4995 };
4996
4997 pat_t mode0[3] =
4998 {
4999 { 0x40000000, 0xfe0003ff },
5000 { 0x04000000, 0xfe000000 },
5001 { 0x4be00001, 0xffff83ff },
5002 };
5003
5004 pat_t mode1[3] =
5005 {
5006 { 0x38007402, 0xfe007fff },
5007 { 0x40007400, 0xfe007fff },
5008 { 0x4be00001, 0xffff83ff },
5009 };
5010
5011 unsigned char *p = contents + rel->r_offset;
5012
5013 uint32_t insn;
5014 uint32_t regidx = 0;
5015 insn = bfd_getb32 (p);
5016 if (INSN_SETHI == (0xfe0fffffu & insn))
5017 {
5018 regidx = 0x1f & (insn >> 20);
5019 p += 4;
5020 }
5021
5022 insn = bfd_getb32 (p);
5023 if (INSN_ORI == (0xfe007fffu & insn))
5024 {
5025 regidx = 0x1f & (insn >> 20);
5026 p += 4;
5027 }
5028
5029 if (patch[2] == bfd_getb32 (p + 8)) /* Character instruction. */
5030 {
5031 /* already patched? */
5032 if ((patch[0] == (0xfff07fffu & bfd_getb32 (p + 0))) &&
5033 (patch[1] == bfd_getb32 (p + 4)))
5034 rz = TRUE;
5035 }
5036 else if (mode0[0].opcode == (mode0[0].mask & bfd_getb32 (p + 0)))
5037 {
5038 if ((mode0[1].opcode == (mode0[1].mask & bfd_getb32 (p + 4))) &&
5039 (mode0[2].opcode == (mode0[2].mask & bfd_getb32 (p + 8))))
5040 {
5041 bfd_putb32 (patch[0] | (regidx << 15), p + 0);
5042 bfd_putb32 (patch[1], p + 4);
5043 bfd_putb32 (patch[2], p + 8);
5044 rz = TRUE;
5045 }
5046 }
5047 else if (mode1[0].opcode == (mode1[0].mask & bfd_getb32 (p + 0)))
5048 {
5049 if ((mode1[1].opcode == (mode1[1].mask & bfd_getb32 (p + 4))) &&
5050 (mode1[2].opcode == (mode1[2].mask & bfd_getb32 (p + 8))))
5051 {
5052 bfd_putb32 (patch[0] | (regidx << 15), p + 0);
5053 bfd_putb32 (patch[1], p + 4);
5054 bfd_putb32 (patch[2], p + 8);
5055 rz = TRUE;
5056 }
5057 }
5058
5059 if (!rz)
5060 {
5061 printf ("%s: %s @ 0x%08x\n", __func__, ibfd->filename,
5062 (int) rel->r_offset);
5063 BFD_ASSERT(0); /* Unsupported pattern. */
5064 }
5065
5066 return rz;
5067 }
5068
5069 static enum elf_nds32_tls_type
5070 get_tls_type (enum elf_nds32_reloc_type r_type, struct elf_link_hash_entry *h);
5071
5072 static unsigned int
5073 ones32 (register unsigned int x)
5074 {
5075 /* 32-bit recursive reduction using SWAR...
5076 but first step is mapping 2-bit values
5077 into sum of 2 1-bit values in sneaky way. */
5078 x -= ((x >> 1) & 0x55555555);
5079 x = (((x >> 2) & 0x33333333) + (x & 0x33333333));
5080 x = (((x >> 4) + x) & 0x0f0f0f0f);
5081 x += (x >> 8);
5082 x += (x >> 16);
5083 return (x & 0x0000003f);
5084 }
5085
5086 #if !HAVE_FLS
5087 static unsigned int
5088 fls (register unsigned int x)
5089 {
5090 return ffs (x & (-x));
5091 }
5092 #endif /* !HAVE_FLS */
5093
5094 #define nds32_elf_local_tlsdesc_gotent(bfd) \
5095 (elf_nds32_tdata (bfd)->local_tlsdesc_gotent)
5096
5097 static bfd_boolean
5098 nds32_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
5099 struct bfd_link_info * info,
5100 bfd * input_bfd,
5101 asection * input_section,
5102 bfd_byte * contents,
5103 Elf_Internal_Rela * relocs,
5104 Elf_Internal_Sym * local_syms,
5105 asection ** local_sections)
5106 {
5107 Elf_Internal_Shdr *symtab_hdr;
5108 struct elf_link_hash_entry **sym_hashes;
5109 Elf_Internal_Rela *rel, *relend;
5110 bfd_boolean ret = TRUE; /* Assume success. */
5111 int align = 0;
5112 bfd_reloc_status_type r;
5113 const char *errmsg = NULL;
5114 bfd_vma gp;
5115 struct elf_link_hash_table *ehtab;
5116 struct elf_nds32_link_hash_table *htab;
5117 bfd *dynobj;
5118 bfd_vma *local_got_offsets;
5119 asection *sgot, *splt, *sreloc;
5120 bfd_vma high_address;
5121 struct elf_nds32_link_hash_table *table;
5122 int eliminate_gc_relocs;
5123 bfd_vma fpbase_addr;
5124
5125 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5126 sym_hashes = elf_sym_hashes (input_bfd);
5127 ehtab = elf_hash_table (info);
5128 htab = nds32_elf_hash_table (info);
5129 high_address = bfd_get_section_limit (input_bfd, input_section);
5130
5131 dynobj = htab->root.dynobj;
5132 local_got_offsets = elf_local_got_offsets (input_bfd);
5133
5134 sgot = ehtab->sgot;
5135 splt = ehtab->splt;
5136 sreloc = NULL;
5137
5138 rel = relocs;
5139 relend = relocs + input_section->reloc_count;
5140
5141 table = nds32_elf_hash_table (info);
5142 eliminate_gc_relocs = table->eliminate_gc_relocs;
5143
5144 /* By this time, we can adjust the value of _SDA_BASE_. */
5145 /* Explain _SDA_BASE_ */
5146 if ((!bfd_link_relocatable (info)))
5147 {
5148 is_SDA_BASE_set = 1;
5149 r = nds32_elf_final_sda_base (output_bfd, info, &gp, TRUE);
5150 if (r != bfd_reloc_ok)
5151 return FALSE;
5152 }
5153
5154 /* Do TLS model conversion once at first. */
5155 nds32_elf_unify_tls_model (input_bfd, input_section, contents, info);
5156
5157 /* Use gp as fp to prevent truncated fit. Because in relaxation time
5158 the fp value is set as gp, and it has be reverted for instruction
5159 setting fp. */
5160 fpbase_addr = elf_gp (output_bfd);
5161
5162 /* Deal with (dynamic) relocations. */
5163 for (rel = relocs; rel < relend; rel++)
5164 {
5165 enum elf_nds32_reloc_type r_type;
5166 reloc_howto_type *howto = NULL;
5167 unsigned long r_symndx;
5168 struct elf_link_hash_entry *h = NULL;
5169 Elf_Internal_Sym *sym = NULL;
5170 asection *sec;
5171 bfd_vma relocation;
5172 bfd_vma relocation_sym = 0xdeadbeef;
5173 Elf_Internal_Rela *lorel;
5174 bfd_vma off;
5175
5176 /* We can't modify r_addend here as elf_link_input_bfd has an assert to
5177 ensure it's zero (we use REL relocs, not RELA). Therefore this
5178 should be assigning zero to `addend', but for clarity we use
5179 `r_addend'. */
5180
5181 bfd_vma addend = rel->r_addend;
5182 bfd_vma offset = rel->r_offset;
5183
5184 r_type = ELF32_R_TYPE (rel->r_info);
5185 if (r_type >= R_NDS32_max)
5186 {
5187 /* xgettext:c-format */
5188 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
5189 input_bfd, r_type);
5190 bfd_set_error (bfd_error_bad_value);
5191 ret = FALSE;
5192 continue;
5193 }
5194
5195 if (r_type == R_NDS32_GNU_VTENTRY
5196 || r_type == R_NDS32_GNU_VTINHERIT
5197 || r_type == R_NDS32_NONE
5198 || r_type == R_NDS32_RELA_GNU_VTENTRY
5199 || r_type == R_NDS32_RELA_GNU_VTINHERIT
5200 || (r_type >= R_NDS32_INSN16 && r_type <= R_NDS32_25_FIXED_RELA)
5201 || r_type == R_NDS32_DATA
5202 || r_type == R_NDS32_TRAN)
5203 continue;
5204
5205 /* If we enter the fp-as-gp region. Resolve the address
5206 of best fp-base. */
5207 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_BEGIN
5208 && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
5209 {
5210 int dist;
5211
5212 /* Distance to relocation of best fp-base is encoded in R_SYM. */
5213 dist = rel->r_addend >> 16;
5214 fpbase_addr = calculate_memory_address (input_bfd, rel + dist,
5215 local_syms, symtab_hdr);
5216 }
5217 else if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_END
5218 && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
5219 {
5220 fpbase_addr = elf_gp (output_bfd);
5221 }
5222
5223 /* Skip the relocations used for relaxation. */
5224 /* We have to update LONGCALL and LONGJUMP
5225 relocations when generating the relocatable files. */
5226 if (!bfd_link_relocatable (info)
5227 && (r_type >= R_NDS32_RELAX_ENTRY
5228 || (r_type >= R_NDS32_LONGCALL4
5229 && r_type <= R_NDS32_LONGJUMP7)))
5230 continue;
5231
5232 howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
5233 r_symndx = ELF32_R_SYM (rel->r_info);
5234
5235 /* This is a final link. */
5236 sym = NULL;
5237 sec = NULL;
5238 h = NULL;
5239
5240 if (r_symndx < symtab_hdr->sh_info)
5241 {
5242 /* Local symbol. */
5243 sym = local_syms + r_symndx;
5244 sec = local_sections[r_symndx];
5245
5246 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
5247 addend = rel->r_addend;
5248
5249 /* keep symbol location for static TLS_IE GOT entry */
5250 relocation_sym = relocation;
5251 if (bfd_link_relocatable (info))
5252 {
5253 /* This is a relocatable link. We don't have to change
5254 anything, unless the reloc is against a section symbol,
5255 in which case we have to adjust according to where the
5256 section symbol winds up in the output section. */
5257 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5258 rel->r_addend += sec->output_offset + sym->st_value;
5259
5260 continue;
5261 }
5262 }
5263 else
5264 {
5265 /* External symbol. */
5266 if (bfd_link_relocatable (info))
5267 continue;
5268 bfd_boolean warned, ignored, unresolved_reloc;
5269 int symndx = r_symndx - symtab_hdr->sh_info;
5270
5271 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
5272 r_symndx, symtab_hdr, sym_hashes, h, sec,
5273 relocation, unresolved_reloc, warned,
5274 ignored);
5275
5276 /* keep symbol location for static TLS_IE GOT entry */
5277 relocation_sym = relocation;
5278
5279 /* la $fp, _FP_BASE_ is per-function (region).
5280 Handle it specially. */
5281 switch ((int) r_type)
5282 {
5283 case R_NDS32_HI20_RELA:
5284 case R_NDS32_LO12S0_RELA:
5285 if (strcmp (elf_sym_hashes (input_bfd)[symndx]->root.root.string,
5286 FP_BASE_NAME) == 0)
5287 {
5288 if (!bfd_link_pie (info))
5289 {
5290 _bfd_error_handler
5291 ("%pB: warning: _FP_BASE_ setting insns relaxation failed.",
5292 input_bfd);
5293 }
5294 relocation = fpbase_addr;
5295 }
5296 break;
5297 case R_NDS32_SDA19S0_RELA:
5298 case R_NDS32_SDA15S0_RELA:
5299 case R_NDS32_20_RELA:
5300 if (strcmp (elf_sym_hashes (input_bfd)[symndx]->root.root.string,
5301 FP_BASE_NAME) == 0)
5302 {
5303 relocation = fpbase_addr;
5304 break;
5305 }
5306 }
5307 }
5308
5309 /* Sanity check the address. */
5310 if (offset > high_address)
5311 {
5312 r = bfd_reloc_outofrange;
5313 goto check_reloc;
5314 }
5315
5316 if (r_type >= R_NDS32_RELAX_ENTRY)
5317 continue;
5318
5319 switch ((int) r_type)
5320 {
5321 case R_NDS32_GOTOFF:
5322 /* Relocation is relative to the start of the global offset
5323 table (for ld24 rx, #uimm24), e.g. access at label+addend
5324
5325 ld24 rx. #label@GOTOFF + addend
5326 sub rx, r12. */
5327 case R_NDS32_GOTOFF_HI20:
5328 case R_NDS32_GOTOFF_LO12:
5329 case R_NDS32_GOTOFF_LO15:
5330 case R_NDS32_GOTOFF_LO19:
5331 BFD_ASSERT (sgot != NULL);
5332
5333 relocation -= elf_gp (output_bfd);
5334 break;
5335
5336 case R_NDS32_9_PLTREL:
5337 case R_NDS32_25_PLTREL:
5338 /* Relocation is to the entry for this symbol in the
5339 procedure linkage table. */
5340
5341 /* The native assembler will generate a 25_PLTREL reloc
5342 for a local symbol if you assemble a call from one
5343 section to another when using -K pic. */
5344 if (h == NULL)
5345 break;
5346
5347 if (h->forced_local)
5348 break;
5349
5350 /* We didn't make a PLT entry for this symbol. This
5351 happens when statically linking PIC code, or when
5352 using -Bsymbolic. */
5353 if (h->plt.offset == (bfd_vma) - 1)
5354 break;
5355
5356 relocation = (splt->output_section->vma
5357 + splt->output_offset + h->plt.offset);
5358 break;
5359
5360 case R_NDS32_PLT_GOTREL_HI20:
5361 case R_NDS32_PLT_GOTREL_LO12:
5362 case R_NDS32_PLT_GOTREL_LO15:
5363 case R_NDS32_PLT_GOTREL_LO19:
5364 case R_NDS32_PLT_GOTREL_LO20:
5365 if (h == NULL
5366 || h->forced_local
5367 || h->plt.offset == (bfd_vma) -1
5368 || (bfd_link_pie (info) && h->def_regular))
5369 {
5370 /* Maybe we should find better checking to optimize
5371 PIE PLT relocations. */
5372 /* We didn't make a PLT entry for this symbol. This
5373 happens when statically linking PIC code, or when
5374 using -Bsymbolic. */
5375 if (h)
5376 h->plt.offset = (bfd_vma) -1; /* Cancel PLT trampoline. */
5377 relocation -= elf_gp (output_bfd);
5378 break;
5379 }
5380
5381 relocation = (splt->output_section->vma
5382 + splt->output_offset + h->plt.offset);
5383
5384 relocation -= elf_gp (output_bfd);
5385 break;
5386
5387 case R_NDS32_PLTREL_HI20:
5388 case R_NDS32_PLTREL_LO12:
5389
5390 /* Relocation is to the entry for this symbol in the
5391 procedure linkage table. */
5392
5393 /* The native assembler will generate a 25_PLTREL reloc
5394 for a local symbol if you assemble a call from one
5395 section to another when using -K pic. */
5396 if (h == NULL)
5397 break;
5398
5399 if (h->forced_local)
5400 break;
5401
5402 if (h->plt.offset == (bfd_vma) - 1)
5403 /* We didn't make a PLT entry for this symbol. This
5404 happens when statically linking PIC code, or when
5405 using -Bsymbolic. */
5406 break;
5407
5408 if (splt == NULL)
5409 break;
5410
5411 relocation = (splt->output_section->vma
5412 + splt->output_offset
5413 + h->plt.offset + 4)
5414 - (input_section->output_section->vma
5415 + input_section->output_offset
5416 + rel->r_offset);
5417
5418 break;
5419
5420 case R_NDS32_GOTPC20:
5421 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
5422 ld24 rx,#_GLOBAL_OFFSET_TABLE_ */
5423 relocation = elf_gp (output_bfd);
5424 break;
5425
5426 case R_NDS32_GOTPC_HI20:
5427 case R_NDS32_GOTPC_LO12:
5428 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
5429 bl .+4
5430 seth rx,#high(_GLOBAL_OFFSET_TABLE_)
5431 or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
5432 or
5433 bl .+4
5434 seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
5435 add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4) */
5436 relocation = elf_gp (output_bfd);
5437 relocation -= (input_section->output_section->vma
5438 + input_section->output_offset + rel->r_offset);
5439 break;
5440
5441 case R_NDS32_GOT20:
5442 /* Fall through. */
5443 case R_NDS32_GOT_HI20:
5444 case R_NDS32_GOT_LO12:
5445 case R_NDS32_GOT_LO15:
5446 case R_NDS32_GOT_LO19:
5447 /* Relocation is to the entry for this symbol in the global
5448 offset table. */
5449 BFD_ASSERT (sgot != NULL);
5450
5451 if (h != NULL)
5452 {
5453 /* External symbol */
5454 bfd_boolean dyn;
5455
5456 off = h->got.offset;
5457 BFD_ASSERT (off != (bfd_vma) - 1);
5458 dyn = htab->root.dynamic_sections_created;
5459 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
5460 bfd_link_pic (info),
5461 h)
5462 || (bfd_link_pic (info)
5463 && (info->symbolic
5464 || h->dynindx == -1
5465 || h->forced_local) && h->def_regular))
5466 {
5467 /* This is actually a static link, or it is a
5468 -Bsymbolic link and the symbol is defined
5469 locally, or the symbol was forced to be local
5470 because of a version file. We must initialize
5471 this entry in the global offset table. Since the
5472 offset must always be a multiple of 4, we use the
5473 least significant bit to record whether we have
5474 initialized it already.
5475
5476 When doing a dynamic link, we create a .rela.got
5477 relocation entry to initialize the value. This
5478 is done in the finish_dynamic_symbol routine. */
5479 if ((off & 1) != 0) /* clear LSB */
5480 off &= ~1;
5481 else
5482 {
5483 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5484 h->got.offset |= 1;
5485 }
5486 }
5487 relocation = sgot->output_section->vma + sgot->output_offset + off
5488 - elf_gp (output_bfd);
5489 }
5490 else
5491 {
5492 /* Local symbol */
5493 bfd_byte *loc;
5494
5495 BFD_ASSERT (local_got_offsets != NULL
5496 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5497
5498 off = local_got_offsets[r_symndx];
5499
5500 /* The offset must always be a multiple of 4. We use
5501 the least significant bit to record whether we have
5502 already processed this entry. */
5503 if ((off & 1) != 0) /* clear LSB */
5504 off &= ~1;
5505 else
5506 {
5507 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5508
5509 if (bfd_link_pic (info))
5510 {
5511 asection *srelgot;
5512 Elf_Internal_Rela outrel;
5513
5514 /* We need to generate a R_NDS32_RELATIVE reloc
5515 for the dynamic linker. */
5516 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5517 BFD_ASSERT (srelgot != NULL);
5518
5519 outrel.r_offset = (elf_gp (output_bfd)
5520 + sgot->output_offset + off);
5521 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5522 outrel.r_addend = relocation;
5523 loc = srelgot->contents;
5524 loc +=
5525 srelgot->reloc_count * sizeof (Elf32_External_Rela);
5526 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5527 ++srelgot->reloc_count;
5528 }
5529 local_got_offsets[r_symndx] |= 1;
5530 }
5531 relocation = sgot->output_section->vma + sgot->output_offset + off
5532 - elf_gp (output_bfd);
5533 }
5534
5535 break;
5536
5537 case R_NDS32_16_RELA:
5538 case R_NDS32_20_RELA:
5539 case R_NDS32_5_RELA:
5540 case R_NDS32_32_RELA:
5541 case R_NDS32_9_PCREL_RELA:
5542 case R_NDS32_WORD_9_PCREL_RELA:
5543 case R_NDS32_10_UPCREL_RELA:
5544 case R_NDS32_15_PCREL_RELA:
5545 case R_NDS32_17_PCREL_RELA:
5546 case R_NDS32_25_PCREL_RELA:
5547 case R_NDS32_HI20_RELA:
5548 case R_NDS32_LO12S3_RELA:
5549 case R_NDS32_LO12S2_RELA:
5550 case R_NDS32_LO12S2_DP_RELA:
5551 case R_NDS32_LO12S2_SP_RELA:
5552 case R_NDS32_LO12S1_RELA:
5553 case R_NDS32_LO12S0_RELA:
5554 case R_NDS32_LO12S0_ORI_RELA:
5555 if (bfd_link_pic (info) && r_symndx != 0
5556 && (input_section->flags & SEC_ALLOC) != 0
5557 && (eliminate_gc_relocs == 0
5558 || (sec && (sec->flags & SEC_EXCLUDE) == 0))
5559 && ((r_type != R_NDS32_9_PCREL_RELA
5560 && r_type != R_NDS32_WORD_9_PCREL_RELA
5561 && r_type != R_NDS32_10_UPCREL_RELA
5562 && r_type != R_NDS32_15_PCREL_RELA
5563 && r_type != R_NDS32_17_PCREL_RELA
5564 && r_type != R_NDS32_25_PCREL_RELA
5565 && !(r_type == R_NDS32_32_RELA
5566 && strcmp (input_section->name, ".eh_frame") == 0))
5567 || (h != NULL && h->dynindx != -1
5568 && (!info->symbolic || !h->def_regular))))
5569 {
5570 Elf_Internal_Rela outrel;
5571 bfd_boolean skip, relocate;
5572 bfd_byte *loc;
5573
5574 /* When generating a shared object, these relocations
5575 are copied into the output file to be resolved at run
5576 time. */
5577
5578 if (sreloc == NULL)
5579 {
5580 const char *name;
5581
5582 name = bfd_elf_string_from_elf_section
5583 (input_bfd, elf_elfheader (input_bfd)->e_shstrndx,
5584 elf_section_data (input_section)->rela.hdr->sh_name);
5585 if (name == NULL)
5586 return FALSE;
5587
5588 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5589 && strcmp (bfd_get_section_name (input_bfd,
5590 input_section),
5591 name + 5) == 0);
5592
5593 sreloc = bfd_get_section_by_name (dynobj, name);
5594 BFD_ASSERT (sreloc != NULL);
5595 }
5596
5597 skip = FALSE;
5598 relocate = FALSE;
5599
5600 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
5601 info,
5602 input_section,
5603 rel->r_offset);
5604 if (outrel.r_offset == (bfd_vma) - 1)
5605 skip = TRUE;
5606 else if (outrel.r_offset == (bfd_vma) - 2)
5607 skip = TRUE, relocate = TRUE;
5608 outrel.r_offset += (input_section->output_section->vma
5609 + input_section->output_offset);
5610
5611 if (skip)
5612 memset (&outrel, 0, sizeof outrel);
5613 else if (r_type == R_NDS32_17_PCREL_RELA
5614 || r_type == R_NDS32_15_PCREL_RELA
5615 || r_type == R_NDS32_25_PCREL_RELA)
5616 {
5617 BFD_ASSERT (h != NULL && h->dynindx != -1);
5618 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
5619 outrel.r_addend = rel->r_addend;
5620 }
5621 else
5622 {
5623 /* h->dynindx may be -1 if this symbol was marked to
5624 become local. */
5625 if (h == NULL
5626 || ((info->symbolic || h->dynindx == -1)
5627 && h->def_regular)
5628 || (bfd_link_pie (info) && h->def_regular))
5629 {
5630 relocate = TRUE;
5631 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5632 outrel.r_addend = relocation + rel->r_addend;
5633
5634 if (h)
5635 {
5636 h->plt.offset = (bfd_vma) -1; /* cancel PLT trampoline. */
5637
5638 BFD_ASSERT (sgot != NULL);
5639 /* If we did not allocate got entry for the symbol,
5640 we can not fill the nonexistent got entry. */
5641 if (h->got.offset != (bfd_vma) -1
5642 && (h->got.offset & 1) == 0)
5643 {
5644 bfd_put_32 (output_bfd, outrel.r_addend,
5645 sgot->contents + h->got.offset);
5646 }
5647 }
5648 }
5649 else
5650 {
5651 if (h->dynindx == -1)
5652 {
5653 _bfd_error_handler
5654 (_("%pB: relocation %s against `%s' can not be used when"
5655 "making a shared object; recompile with -fPIC"),
5656 input_bfd, nds32_elf_howto_table[r_type].name, h->root.root.string);
5657 bfd_set_error (bfd_error_bad_value);
5658 return FALSE;
5659 }
5660
5661 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
5662 outrel.r_addend = rel->r_addend;
5663 }
5664 }
5665
5666 loc = sreloc->contents;
5667 loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
5668 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5669 ++sreloc->reloc_count;
5670
5671 /* If this reloc is against an external symbol, we do
5672 not want to fiddle with the addend. Otherwise, we
5673 need to include the symbol value so that it becomes
5674 an addend for the dynamic reloc. */
5675 if (!relocate)
5676 continue;
5677 }
5678 break;
5679
5680 case R_NDS32_25_ABS_RELA:
5681 if (bfd_link_pic (info))
5682 {
5683 _bfd_error_handler
5684 (_("%pB: warning: %s unsupported in shared mode"),
5685 input_bfd, "R_NDS32_25_ABS_RELA");
5686 return FALSE;
5687 }
5688 break;
5689
5690 case R_NDS32_9_PCREL:
5691 r = nds32_elf_do_9_pcrel_reloc (input_bfd, howto, input_section,
5692 contents, offset,
5693 sec, relocation, addend);
5694 goto check_reloc;
5695
5696 case R_NDS32_HI20:
5697 /* We allow an arbitrary number of HI20 relocs before the
5698 LO12 reloc. This permits gcc to emit the HI and LO relocs
5699 itself. */
5700 for (lorel = rel + 1;
5701 (lorel < relend
5702 && ELF32_R_TYPE (lorel->r_info) == R_NDS32_HI20); lorel++)
5703 continue;
5704 if (lorel < relend
5705 && (ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S3
5706 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S2
5707 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S1
5708 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S0))
5709 {
5710 nds32_elf_relocate_hi20 (input_bfd, r_type, rel, lorel,
5711 contents, relocation + addend);
5712 r = bfd_reloc_ok;
5713 }
5714 else
5715 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5716 contents, offset, relocation,
5717 addend);
5718 goto check_reloc;
5719
5720 case R_NDS32_GOT17S2_RELA:
5721 case R_NDS32_GOT15S2_RELA:
5722 BFD_ASSERT (sgot != NULL);
5723
5724 if (h != NULL)
5725 {
5726 bfd_boolean dyn;
5727
5728 off = h->got.offset;
5729 BFD_ASSERT (off != (bfd_vma) - 1);
5730
5731 dyn = htab->root.dynamic_sections_created;
5732 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL
5733 (dyn, bfd_link_pic (info), h)
5734 || (bfd_link_pic (info)
5735 && (info->symbolic
5736 || h->dynindx == -1
5737 || h->forced_local)
5738 && h->def_regular))
5739 {
5740 /* This is actually a static link, or it is a
5741 -Bsymbolic link and the symbol is defined
5742 locally, or the symbol was forced to be local
5743 because of a version file. We must initialize
5744 this entry in the global offset table. Since the
5745 offset must always be a multiple of 4, we use the
5746 least significant bit to record whether we have
5747 initialized it already.
5748
5749 When doing a dynamic link, we create a .rela.got
5750 relocation entry to initialize the value. This
5751 is done in the finish_dynamic_symbol routine. */
5752 if ((off & 1) != 0)
5753 off &= ~1;
5754 else
5755 {
5756 bfd_put_32 (output_bfd, relocation,
5757 sgot->contents + off);
5758 h->got.offset |= 1;
5759 }
5760 }
5761 }
5762 else
5763 {
5764 bfd_byte *loc;
5765
5766 BFD_ASSERT (local_got_offsets != NULL
5767 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5768
5769 off = local_got_offsets[r_symndx];
5770
5771 /* The offset must always be a multiple of 4. We use
5772 the least significant bit to record whether we have
5773 already processed this entry. */
5774 if ((off & 1) != 0)
5775 off &= ~1;
5776 else
5777 {
5778 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5779
5780 if (bfd_link_pic (info))
5781 {
5782 asection *srelgot;
5783 Elf_Internal_Rela outrel;
5784
5785 /* We need to generate a R_NDS32_RELATIVE reloc
5786 for the dynamic linker. */
5787 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5788 BFD_ASSERT (srelgot != NULL);
5789
5790 outrel.r_offset = (elf_gp (output_bfd)
5791 + sgot->output_offset + off);
5792 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5793 outrel.r_addend = relocation;
5794 loc = srelgot->contents;
5795 loc +=
5796 srelgot->reloc_count * sizeof (Elf32_External_Rela);
5797 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5798 ++srelgot->reloc_count;
5799 }
5800 local_got_offsets[r_symndx] |= 1;
5801 }
5802 }
5803 relocation = sgot->output_section->vma + sgot->output_offset + off
5804 - elf_gp (output_bfd);
5805
5806 if (relocation & align)
5807 {
5808 /* Incorrect alignment. */
5809 _bfd_error_handler
5810 (_("%pB: warning: unaligned access to GOT entry"), input_bfd);
5811 ret = FALSE;
5812 r = bfd_reloc_dangerous;
5813 goto check_reloc;
5814 }
5815 break;
5816
5817 case R_NDS32_SDA16S3_RELA:
5818 case R_NDS32_SDA15S3_RELA:
5819 case R_NDS32_SDA15S3:
5820 align = 0x7;
5821 goto handle_sda;
5822
5823 case R_NDS32_SDA17S2_RELA:
5824 case R_NDS32_SDA15S2_RELA:
5825 case R_NDS32_SDA12S2_SP_RELA:
5826 case R_NDS32_SDA12S2_DP_RELA:
5827 case R_NDS32_SDA15S2:
5828 case R_NDS32_SDA_FP7U2_RELA:
5829 align = 0x3;
5830 goto handle_sda;
5831
5832 case R_NDS32_SDA18S1_RELA:
5833 case R_NDS32_SDA15S1_RELA:
5834 case R_NDS32_SDA15S1:
5835 align = 0x1;
5836 goto handle_sda;
5837
5838 case R_NDS32_SDA19S0_RELA:
5839 case R_NDS32_SDA15S0_RELA:
5840 case R_NDS32_SDA15S0:
5841 align = 0x0;
5842 handle_sda:
5843 BFD_ASSERT (sec != NULL);
5844
5845 /* If the symbol is in the abs section, the out_bfd will be null.
5846 This happens when the relocation has a symbol@GOTOFF. */
5847 r = nds32_elf_final_sda_base (output_bfd, info, &gp, FALSE);
5848 if (r != bfd_reloc_ok)
5849 {
5850 _bfd_error_handler
5851 (_("%pB: warning: relocate SDA_BASE failed"), input_bfd);
5852 ret = FALSE;
5853 goto check_reloc;
5854 }
5855
5856 /* At this point `relocation' contains the object's
5857 address. */
5858 if (r_type == R_NDS32_SDA_FP7U2_RELA)
5859 {
5860 relocation -= fpbase_addr;
5861 }
5862 else
5863 relocation -= gp;
5864 /* Now it contains the offset from _SDA_BASE_. */
5865
5866 /* Make sure alignment is correct. */
5867
5868 if (relocation & align)
5869 {
5870 /* Incorrect alignment. */
5871 _bfd_error_handler
5872 /* xgettext:c-format */
5873 (_("%pB(%pA): warning: unaligned small data access"
5874 " of type %d"),
5875 input_bfd, input_section, r_type);
5876 ret = FALSE;
5877 goto check_reloc;
5878 }
5879 break;
5880
5881 case R_NDS32_17IFC_PCREL_RELA:
5882 case R_NDS32_10IFCU_PCREL_RELA:
5883 /* Do nothing. */
5884 break;
5885
5886 case R_NDS32_TLS_LE_HI20:
5887 case R_NDS32_TLS_LE_LO12:
5888 case R_NDS32_TLS_LE_20:
5889 case R_NDS32_TLS_LE_15S0:
5890 case R_NDS32_TLS_LE_15S1:
5891 case R_NDS32_TLS_LE_15S2:
5892 /* We do not have garbage collection for got entries.
5893 Therefore, IE to LE may have one empty entry, and DESC to
5894 LE may have two. */
5895 if (elf_hash_table (info)->tls_sec != NULL)
5896 relocation -= (elf_hash_table (info)->tls_sec->vma + TP_OFFSET);
5897 break;
5898
5899 case R_NDS32_TLS_IE_HI20:
5900 case R_NDS32_TLS_IE_LO12S2:
5901 case R_NDS32_TLS_DESC_HI20:
5902 case R_NDS32_TLS_DESC_LO12:
5903 case R_NDS32_TLS_IE_LO12:
5904 case R_NDS32_TLS_IEGP_HI20:
5905 case R_NDS32_TLS_IEGP_LO12:
5906 case R_NDS32_TLS_IEGP_LO12S2:
5907 {
5908 /* Relocation is to the entry for this symbol in the global
5909 offset table. */
5910 enum elf_nds32_tls_type tls_type, org_tls_type, eff_tls_type;
5911 asection *srelgot;
5912 Elf_Internal_Rela outrel;
5913 bfd_byte *loc;
5914 int indx = 0;
5915
5916 eff_tls_type = org_tls_type = get_tls_type (r_type, h);
5917
5918 BFD_ASSERT (sgot != NULL);
5919 if (h != NULL)
5920 {
5921 bfd_boolean dyn;
5922
5923 off = h->got.offset;
5924 BFD_ASSERT (off != (bfd_vma) -1);
5925 dyn = htab->root.dynamic_sections_created;
5926 tls_type = ((struct elf_nds32_link_hash_entry *) h)->tls_type;
5927 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
5928 && (!bfd_link_pic (info)
5929 || !SYMBOL_REFERENCES_LOCAL (info, h)))
5930 indx = h->dynindx;
5931 }
5932 else
5933 {
5934 BFD_ASSERT (local_got_offsets != NULL
5935 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5936 off = local_got_offsets[r_symndx];
5937 tls_type = elf32_nds32_local_got_tls_type (input_bfd)[r_symndx];
5938 }
5939
5940 relocation = sgot->output_section->vma + sgot->output_offset + off;
5941
5942 if (1 < ones32 (tls_type))
5943 {
5944 eff_tls_type = 1 << (fls (tls_type) - 1);
5945 /* TLS model shall be handled in nds32_elf_unify_tls_model (). */
5946
5947 /* TLS model X -> LE is not implement yet!
5948 workaround here! */
5949 if (eff_tls_type == GOT_TLS_LE)
5950 {
5951 eff_tls_type = 1 << (fls (tls_type ^ eff_tls_type) - 1);
5952 }
5953 }
5954
5955 /* The offset must always be a multiple of 4. We use
5956 the least significant bit to record whether we have
5957 already processed this entry. */
5958 bfd_boolean need_relocs = FALSE;
5959 srelgot = ehtab->srelgot;
5960 if ((bfd_link_pic (info) || indx != 0)
5961 && (h == NULL || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5962 || h->root.type != bfd_link_hash_undefweak))
5963 {
5964 need_relocs = TRUE;
5965 BFD_ASSERT (srelgot != NULL);
5966 }
5967
5968 if (off & 1)
5969 {
5970 off &= ~1;
5971 relocation &= ~1;
5972
5973 if (eff_tls_type & GOT_TLS_DESC)
5974 {
5975 relocation -= elf_gp (output_bfd);
5976 if ((R_NDS32_TLS_DESC_HI20 == r_type) && (!need_relocs))
5977 {
5978 /* TLS model shall be converted. */
5979 BFD_ASSERT(0);
5980 }
5981 }
5982 else if (eff_tls_type & GOT_TLS_IEGP)
5983 {
5984 relocation -= elf_gp (output_bfd);
5985 }
5986 }
5987 else
5988 {
5989 if ((eff_tls_type & GOT_TLS_LE) && (tls_type ^ eff_tls_type))
5990 {
5991 /* TLS model workaround shall be applied. */
5992 BFD_ASSERT(0);
5993 }
5994 else if (eff_tls_type & (GOT_TLS_IE | GOT_TLS_IEGP))
5995 {
5996 if (eff_tls_type & GOT_TLS_IEGP)
5997 relocation -= elf_gp(output_bfd);
5998
5999 if (need_relocs)
6000 {
6001 if (indx == 0)
6002 outrel.r_addend = gottpoff (info, relocation_sym);
6003 else
6004 outrel.r_addend = 0;
6005 outrel.r_offset = (sgot->output_section->vma
6006 + sgot->output_offset + off);
6007 outrel.r_info = ELF32_R_INFO (indx, R_NDS32_TLS_TPOFF);
6008
6009 elf32_nds32_add_dynreloc (output_bfd, info, srelgot,
6010 &outrel);
6011 }
6012 else
6013 {
6014 bfd_put_32 (output_bfd, gottpoff (info, relocation_sym),
6015 sgot->contents + off);
6016 }
6017 }
6018 else if (eff_tls_type & GOT_TLS_DESC)
6019 {
6020 relocation -= elf_gp (output_bfd);
6021 if (need_relocs)
6022 {
6023 if (indx == 0)
6024 outrel.r_addend = gottpoff (info, relocation_sym);
6025 else
6026 outrel.r_addend = 0;
6027 outrel.r_offset = (sgot->output_section->vma
6028 + sgot->output_offset + off);
6029 outrel.r_info = ELF32_R_INFO (indx, R_NDS32_TLS_DESC);
6030
6031 if (htab->tls_desc_trampoline)
6032 {
6033 asection *srelplt;
6034 srelplt = ehtab->srelplt;
6035 loc = srelplt->contents;
6036 loc += htab->next_tls_desc_index++ * sizeof (Elf32_External_Rela);
6037 BFD_ASSERT (loc + sizeof (Elf32_External_Rela)
6038 <= srelplt->contents + srelplt->size);
6039
6040 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
6041 }
6042 else
6043 {
6044 loc = srelgot->contents;
6045 loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
6046 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
6047 ++srelgot->reloc_count;
6048 }
6049 }
6050 else
6051 {
6052 /* feed me! */
6053 bfd_put_32 (output_bfd, 0xdeadbeef,
6054 sgot->contents + off);
6055 bfd_put_32 (output_bfd, gottpoff (info, relocation_sym),
6056 sgot->contents + off + 4);
6057 patch_tls_desc_to_ie (contents, rel, input_bfd);
6058 BFD_ASSERT(0);
6059 }
6060 }
6061 else
6062 {
6063 /* TLS model workaround shall be applied. */
6064 BFD_ASSERT(0);
6065 }
6066
6067 if (h != NULL)
6068 h->got.offset |= 1;
6069 else
6070 local_got_offsets[r_symndx] |= 1;
6071 }
6072 }
6073 break;
6074 /* DON'T fall through. */
6075
6076 default:
6077 /* OLD_NDS32_RELOC. */
6078
6079 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
6080 contents, offset, relocation, addend);
6081 goto check_reloc;
6082 }
6083
6084 switch ((int) r_type)
6085 {
6086 case R_NDS32_20_RELA:
6087 case R_NDS32_5_RELA:
6088 case R_NDS32_9_PCREL_RELA:
6089 case R_NDS32_WORD_9_PCREL_RELA:
6090 case R_NDS32_10_UPCREL_RELA:
6091 case R_NDS32_15_PCREL_RELA:
6092 case R_NDS32_17_PCREL_RELA:
6093 case R_NDS32_25_PCREL_RELA:
6094 case R_NDS32_25_ABS_RELA:
6095 case R_NDS32_HI20_RELA:
6096 case R_NDS32_LO12S3_RELA:
6097 case R_NDS32_LO12S2_RELA:
6098 case R_NDS32_LO12S2_DP_RELA:
6099 case R_NDS32_LO12S2_SP_RELA:
6100 case R_NDS32_LO12S1_RELA:
6101 case R_NDS32_LO12S0_RELA:
6102 case R_NDS32_LO12S0_ORI_RELA:
6103 case R_NDS32_SDA16S3_RELA:
6104 case R_NDS32_SDA17S2_RELA:
6105 case R_NDS32_SDA18S1_RELA:
6106 case R_NDS32_SDA19S0_RELA:
6107 case R_NDS32_SDA15S3_RELA:
6108 case R_NDS32_SDA15S2_RELA:
6109 case R_NDS32_SDA12S2_DP_RELA:
6110 case R_NDS32_SDA12S2_SP_RELA:
6111 case R_NDS32_SDA15S1_RELA:
6112 case R_NDS32_SDA15S0_RELA:
6113 case R_NDS32_SDA_FP7U2_RELA:
6114 case R_NDS32_9_PLTREL:
6115 case R_NDS32_25_PLTREL:
6116 case R_NDS32_GOT20:
6117 case R_NDS32_GOT_HI20:
6118 case R_NDS32_GOT_LO12:
6119 case R_NDS32_GOT_LO15:
6120 case R_NDS32_GOT_LO19:
6121 case R_NDS32_GOT15S2_RELA:
6122 case R_NDS32_GOT17S2_RELA:
6123 case R_NDS32_GOTPC20:
6124 case R_NDS32_GOTPC_HI20:
6125 case R_NDS32_GOTPC_LO12:
6126 case R_NDS32_GOTOFF:
6127 case R_NDS32_GOTOFF_HI20:
6128 case R_NDS32_GOTOFF_LO12:
6129 case R_NDS32_GOTOFF_LO15:
6130 case R_NDS32_GOTOFF_LO19:
6131 case R_NDS32_PLTREL_HI20:
6132 case R_NDS32_PLTREL_LO12:
6133 case R_NDS32_PLT_GOTREL_HI20:
6134 case R_NDS32_PLT_GOTREL_LO12:
6135 case R_NDS32_PLT_GOTREL_LO15:
6136 case R_NDS32_PLT_GOTREL_LO19:
6137 case R_NDS32_PLT_GOTREL_LO20:
6138 case R_NDS32_17IFC_PCREL_RELA:
6139 case R_NDS32_10IFCU_PCREL_RELA:
6140 case R_NDS32_TLS_LE_HI20:
6141 case R_NDS32_TLS_LE_LO12:
6142 case R_NDS32_TLS_IE_HI20:
6143 case R_NDS32_TLS_IE_LO12S2:
6144 case R_NDS32_TLS_LE_20:
6145 case R_NDS32_TLS_LE_15S0:
6146 case R_NDS32_TLS_LE_15S1:
6147 case R_NDS32_TLS_LE_15S2:
6148 case R_NDS32_TLS_DESC_HI20:
6149 case R_NDS32_TLS_DESC_LO12:
6150 case R_NDS32_TLS_IE_LO12:
6151 case R_NDS32_TLS_IEGP_HI20:
6152 case R_NDS32_TLS_IEGP_LO12:
6153 case R_NDS32_TLS_IEGP_LO12S2:
6154 /* Instruction related relocs must handle endian properly. */
6155 /* NOTE: PIC IS NOT HANDLE YET; DO IT LATER. */
6156 r = nds32_elf_final_link_relocate (howto, input_bfd,
6157 input_section, contents,
6158 rel->r_offset, relocation,
6159 rel->r_addend);
6160 break;
6161
6162 default:
6163 /* All other relocs can use default handler. */
6164 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
6165 contents, rel->r_offset,
6166 relocation, rel->r_addend);
6167 break;
6168 }
6169
6170 check_reloc:
6171
6172 if (r != bfd_reloc_ok)
6173 {
6174 /* FIXME: This should be generic enough to go in a utility. */
6175 const char *name;
6176
6177 if (h != NULL)
6178 name = h->root.root.string;
6179 else
6180 {
6181 name = bfd_elf_string_from_elf_section
6182 (input_bfd, symtab_hdr->sh_link, sym->st_name);
6183 if (name == NULL || *name == '\0')
6184 name = bfd_section_name (input_bfd, sec);
6185 }
6186
6187 if (errmsg != NULL)
6188 goto common_error;
6189
6190 switch (r)
6191 {
6192 case bfd_reloc_overflow:
6193 (*info->callbacks->reloc_overflow)
6194 (info, (h ? &h->root : NULL), name, howto->name,
6195 (bfd_vma) 0, input_bfd, input_section, offset);
6196 break;
6197
6198 case bfd_reloc_undefined:
6199 (*info->callbacks->undefined_symbol)
6200 (info, name, input_bfd, input_section, offset, TRUE);
6201 break;
6202
6203 case bfd_reloc_outofrange:
6204 errmsg = _("internal error: out of range error");
6205 goto common_error;
6206
6207 case bfd_reloc_notsupported:
6208 errmsg = _("internal error: unsupported relocation error");
6209 goto common_error;
6210
6211 case bfd_reloc_dangerous:
6212 errmsg = _("internal error: dangerous error");
6213 goto common_error;
6214
6215 default:
6216 errmsg = _("internal error: unknown error");
6217 /* Fall through. */
6218
6219 common_error:
6220 (*info->callbacks->warning) (info, errmsg, name, input_bfd,
6221 input_section, offset);
6222 break;
6223 }
6224 }
6225 }
6226
6227 /* Resotre header size to avoid overflow load. */
6228 if (elf_nds32_tdata (input_bfd)->hdr_size != 0)
6229 symtab_hdr->sh_size = elf_nds32_tdata (input_bfd)->hdr_size;
6230
6231 return ret;
6232 }
6233
6234 /* Finish up dynamic symbol handling. We set the contents of various
6235 dynamic sections here. */
6236
6237 static bfd_boolean
6238 nds32_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
6239 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)
6240 {
6241 struct elf_link_hash_table *ehtab;
6242 struct elf_nds32_link_hash_entry *hent;
6243 bfd_byte *loc;
6244
6245 ehtab = elf_hash_table (info);
6246 hent = (struct elf_nds32_link_hash_entry *) h;
6247
6248 if (h->plt.offset != (bfd_vma) - 1)
6249 {
6250 asection *splt;
6251 asection *sgot;
6252 asection *srela;
6253
6254 bfd_vma plt_index;
6255 bfd_vma got_offset;
6256 bfd_vma local_plt_offset;
6257 Elf_Internal_Rela rela;
6258
6259 /* This symbol has an entry in the procedure linkage table. Set
6260 it up. */
6261
6262 BFD_ASSERT (h->dynindx != -1);
6263
6264 splt = ehtab->splt;
6265 sgot = ehtab->sgotplt;
6266 srela = ehtab->srelplt;
6267 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
6268
6269 /* Get the index in the procedure linkage table which
6270 corresponds to this symbol. This is the index of this symbol
6271 in all the symbols for which we are making plt entries. The
6272 first entry in the procedure linkage table is reserved. */
6273 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
6274
6275 /* Get the offset into the .got table of the entry that
6276 corresponds to this function. Each .got entry is 4 bytes.
6277 The first three are reserved. */
6278 got_offset = (plt_index + 3) * 4;
6279
6280 /* Fill in the entry in the procedure linkage table. */
6281 if (!bfd_link_pic (info))
6282 {
6283 unsigned long insn;
6284
6285 insn = PLT_ENTRY_WORD0 + (((sgot->output_section->vma
6286 + sgot->output_offset + got_offset) >> 12)
6287 & 0xfffff);
6288 bfd_putb32 (insn, splt->contents + h->plt.offset);
6289
6290 insn = PLT_ENTRY_WORD1 + (((sgot->output_section->vma
6291 + sgot->output_offset + got_offset) & 0x0fff)
6292 >> 2);
6293 bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
6294
6295 insn = PLT_ENTRY_WORD2;
6296 bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
6297
6298 insn = PLT_ENTRY_WORD3 + (plt_index & 0x7ffff);
6299 bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
6300
6301 insn = PLT_ENTRY_WORD4
6302 + (((unsigned int) ((-(h->plt.offset + 16)) >> 1)) & 0xffffff);
6303 bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
6304 local_plt_offset = 12;
6305 }
6306 else
6307 {
6308 /* sda_base must be set at this time. */
6309 unsigned long insn;
6310 long offset;
6311
6312 offset = sgot->output_section->vma + sgot->output_offset + got_offset
6313 - elf_gp (output_bfd);
6314 insn = PLT_PIC_ENTRY_WORD0 + ((offset >> 12) & 0xfffff);
6315 bfd_putb32 (insn, splt->contents + h->plt.offset);
6316
6317 insn = PLT_PIC_ENTRY_WORD1 + (offset & 0xfff);
6318 bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
6319
6320 insn = PLT_PIC_ENTRY_WORD2;
6321 bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
6322
6323 insn = PLT_PIC_ENTRY_WORD3;
6324 bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
6325
6326 insn = PLT_PIC_ENTRY_WORD4 + (plt_index & 0x7fffff);
6327 bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
6328
6329 insn = PLT_PIC_ENTRY_WORD5
6330 + (((unsigned int) ((-(h->plt.offset + 20)) >> 1)) & 0xffffff);
6331 bfd_putb32 (insn, splt->contents + h->plt.offset + 20);
6332
6333 local_plt_offset = 16;
6334 }
6335
6336 /* Fill in the entry in the global offset table,
6337 so it will fall through to the next instruction for the first time. */
6338 bfd_put_32 (output_bfd,
6339 (splt->output_section->vma + splt->output_offset
6340 + h->plt.offset + local_plt_offset),
6341 sgot->contents + got_offset);
6342
6343 /* Fill in the entry in the .rela.plt section. */
6344 rela.r_offset = (sgot->output_section->vma
6345 + sgot->output_offset + got_offset);
6346 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_JMP_SLOT);
6347 rela.r_addend = 0;
6348 loc = srela->contents;
6349 loc += plt_index * sizeof (Elf32_External_Rela);
6350 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
6351
6352 if (!h->def_regular)
6353 {
6354 /* Mark the symbol as undefined, rather than as defined in
6355 the .plt section. Leave the value alone. */
6356 sym->st_shndx = SHN_UNDEF;
6357 if (!h->ref_regular_nonweak)
6358 sym->st_value = 0;
6359 }
6360 }
6361
6362 if (h->got.offset != (bfd_vma) - 1
6363 && hent->tls_type == GOT_NORMAL)
6364 {
6365 asection *sgot;
6366 asection *srelagot;
6367 Elf_Internal_Rela rela;
6368
6369 /* This symbol has an entry in the global offset table.
6370 Set it up. */
6371
6372 sgot = ehtab->sgot;
6373 srelagot = ehtab->srelgot;
6374 BFD_ASSERT (sgot != NULL && srelagot != NULL);
6375
6376 rela.r_offset = (sgot->output_section->vma
6377 + sgot->output_offset + (h->got.offset & ~1));
6378
6379 /* If this is a -Bsymbolic link, and the symbol is defined
6380 locally, we just want to emit a RELATIVE reloc. Likewise if
6381 the symbol was forced to be local because of a version file.
6382 The entry in the global offset table will already have been
6383 initialized in the relocate_section function. */
6384 if ((bfd_link_pic (info)
6385 && (info->symbolic || h->dynindx == -1 || h->forced_local)
6386 && h->def_regular)
6387 || (bfd_link_pie (info) && h->def_regular))
6388 {
6389 rela.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
6390 rela.r_addend = (h->root.u.def.value
6391 + h->root.u.def.section->output_section->vma
6392 + h->root.u.def.section->output_offset);
6393
6394 if ((h->got.offset & 1) == 0)
6395 {
6396 bfd_put_32 (output_bfd, rela.r_addend,
6397 sgot->contents + h->got.offset);
6398 }
6399 }
6400 else
6401 {
6402 BFD_ASSERT ((h->got.offset & 1) == 0);
6403 bfd_put_32 (output_bfd, (bfd_vma) 0,
6404 sgot->contents + h->got.offset);
6405 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_GLOB_DAT);
6406 rela.r_addend = 0;
6407 }
6408
6409 loc = srelagot->contents;
6410 loc += srelagot->reloc_count * sizeof (Elf32_External_Rela);
6411 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
6412 ++srelagot->reloc_count;
6413 BFD_ASSERT (loc < (srelagot->contents + srelagot->size));
6414 }
6415
6416 if (h->needs_copy)
6417 {
6418 asection *s;
6419 Elf_Internal_Rela rela;
6420
6421 /* This symbols needs a copy reloc. Set it up. */
6422
6423 BFD_ASSERT (h->dynindx != -1
6424 && (h->root.type == bfd_link_hash_defined
6425 || h->root.type == bfd_link_hash_defweak));
6426
6427 s = bfd_get_section_by_name (h->root.u.def.section->owner, ".rela.bss");
6428 BFD_ASSERT (s != NULL);
6429
6430 rela.r_offset = (h->root.u.def.value
6431 + h->root.u.def.section->output_section->vma
6432 + h->root.u.def.section->output_offset);
6433 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_COPY);
6434 rela.r_addend = 0;
6435 loc = s->contents;
6436 loc += s->reloc_count * sizeof (Elf32_External_Rela);
6437 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
6438 ++s->reloc_count;
6439 }
6440
6441 /* Mark some specially defined symbols as absolute. */
6442 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
6443 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
6444 sym->st_shndx = SHN_ABS;
6445
6446 return TRUE;
6447 }
6448
6449
6450 /* Finish up the dynamic sections. */
6451
6452 static bfd_boolean
6453 nds32_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
6454 {
6455 bfd *dynobj;
6456 asection *sdyn;
6457 asection *sgotplt;
6458 struct elf_link_hash_table *ehtab;
6459 struct elf_nds32_link_hash_table *htab;
6460
6461 ehtab = elf_hash_table (info);
6462 htab = nds32_elf_hash_table (info);
6463 if (htab == NULL)
6464 return FALSE;
6465
6466 dynobj = elf_hash_table (info)->dynobj;
6467
6468 sgotplt = ehtab->sgotplt;
6469 /* A broken linker script might have discarded the dynamic sections.
6470 Catch this here so that we do not seg-fault later on. */
6471 if (sgotplt != NULL && bfd_is_abs_section (sgotplt->output_section))
6472 return FALSE;
6473 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
6474
6475 if (elf_hash_table (info)->dynamic_sections_created)
6476 {
6477 asection *splt;
6478 Elf32_External_Dyn *dyncon, *dynconend;
6479
6480 BFD_ASSERT (sgotplt != NULL && sdyn != NULL);
6481
6482 dyncon = (Elf32_External_Dyn *) sdyn->contents;
6483 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
6484
6485 for (; dyncon < dynconend; dyncon++)
6486 {
6487 Elf_Internal_Dyn dyn;
6488 asection *s;
6489
6490 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
6491
6492 switch (dyn.d_tag)
6493 {
6494 default:
6495 break;
6496
6497 case DT_PLTGOT:
6498 /* name = ".got"; */
6499 s = ehtab->sgot->output_section;
6500 goto get_vma;
6501 case DT_JMPREL:
6502 s = ehtab->srelplt->output_section;
6503 get_vma:
6504 BFD_ASSERT (s != NULL);
6505 dyn.d_un.d_ptr = s->vma;
6506 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6507 break;
6508
6509 case DT_PLTRELSZ:
6510 s = ehtab->srelplt->output_section;
6511 BFD_ASSERT (s != NULL);
6512 dyn.d_un.d_val = s->size;
6513 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6514 break;
6515
6516 case DT_RELASZ:
6517 /* My reading of the SVR4 ABI indicates that the
6518 procedure linkage table relocs (DT_JMPREL) should be
6519 included in the overall relocs (DT_RELA). This is
6520 what Solaris does. However, UnixWare can not handle
6521 that case. Therefore, we override the DT_RELASZ entry
6522 here to make it not include the JMPREL relocs. Since
6523 the linker script arranges for .rela.plt to follow all
6524 other relocation sections, we don't have to worry
6525 about changing the DT_RELA entry. */
6526 if (ehtab->srelplt != NULL)
6527 {
6528 s = ehtab->srelplt->output_section;
6529 dyn.d_un.d_val -= s->size;
6530 }
6531 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6532 break;
6533
6534 case DT_TLSDESC_PLT:
6535 s = htab->root.splt;
6536 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
6537 + htab->dt_tlsdesc_plt);
6538 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6539 break;
6540
6541 case DT_TLSDESC_GOT:
6542 s = htab->root.sgot;
6543 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
6544 + htab->dt_tlsdesc_got);
6545 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6546 break;
6547 }
6548 }
6549
6550 /* Fill in the first entry in the procedure linkage table. */
6551 splt = ehtab->splt;
6552 if (splt && splt->size > 0)
6553 {
6554 if (bfd_link_pic (info))
6555 {
6556 unsigned long insn;
6557 long offset;
6558
6559 offset = sgotplt->output_section->vma + sgotplt->output_offset + 4
6560 - elf_gp (output_bfd);
6561 insn = PLT0_PIC_ENTRY_WORD0 | ((offset >> 12) & 0xfffff);
6562 bfd_putb32 (insn, splt->contents);
6563
6564 /* here has a typo? */
6565 insn = PLT0_PIC_ENTRY_WORD1 | (offset & 0xfff);
6566 bfd_putb32 (insn, splt->contents + 4);
6567
6568 insn = PLT0_PIC_ENTRY_WORD2;
6569 bfd_putb32 (insn, splt->contents + 8);
6570
6571 insn = PLT0_PIC_ENTRY_WORD3;
6572 bfd_putb32 (insn, splt->contents + 12);
6573
6574 insn = PLT0_PIC_ENTRY_WORD4;
6575 bfd_putb32 (insn, splt->contents + 16);
6576
6577 insn = PLT0_PIC_ENTRY_WORD5;
6578 bfd_putb32 (insn, splt->contents + 20);
6579 }
6580 else
6581 {
6582 unsigned long insn;
6583 unsigned long addr;
6584
6585 /* addr = .got + 4 */
6586 addr = sgotplt->output_section->vma + sgotplt->output_offset + 4;
6587 insn = PLT0_ENTRY_WORD0 | ((addr >> 12) & 0xfffff);
6588 bfd_putb32 (insn, splt->contents);
6589
6590 insn = PLT0_ENTRY_WORD1 | (addr & 0x0fff);
6591 bfd_putb32 (insn, splt->contents + 4);
6592
6593 insn = PLT0_ENTRY_WORD2;
6594 bfd_putb32 (insn, splt->contents + 8);
6595
6596 insn = PLT0_ENTRY_WORD3;
6597 bfd_putb32 (insn, splt->contents + 12);
6598
6599 insn = PLT0_ENTRY_WORD4;
6600 bfd_putb32 (insn, splt->contents + 16);
6601 }
6602
6603 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
6604 PLT_ENTRY_SIZE;
6605 }
6606
6607 if (htab->dt_tlsdesc_plt)
6608 {
6609 /* Calculate addresses. */
6610 asection *sgot = sgot = ehtab->sgot;
6611 bfd_vma pltgot = sgotplt->output_section->vma
6612 + sgotplt->output_offset;
6613 bfd_vma tlsdesc_got = sgot->output_section->vma + sgot->output_offset
6614 + htab->dt_tlsdesc_got;
6615
6616 /* Get GP offset. */
6617 pltgot -= elf_gp (output_bfd) - 4; /* PLTGOT[1] */
6618 tlsdesc_got -= elf_gp (output_bfd);
6619
6620 /* Do relocation. */
6621 dl_tlsdesc_lazy_trampoline[0] += ((1 << 20) - 1) & (tlsdesc_got >> 12);
6622 dl_tlsdesc_lazy_trampoline[1] += 0xfff & tlsdesc_got;
6623 dl_tlsdesc_lazy_trampoline[4] += ((1 << 20) - 1) & (pltgot >> 12);
6624 dl_tlsdesc_lazy_trampoline[5] += 0xfff & pltgot;
6625
6626 /* Insert .plt. */
6627 nds32_put_trampoline (splt->contents + htab->dt_tlsdesc_plt,
6628 dl_tlsdesc_lazy_trampoline,
6629 ARRAY_SIZE (dl_tlsdesc_lazy_trampoline));
6630 }
6631 }
6632
6633 /* Fill in the first three entries in the global offset table. */
6634 if (sgotplt && sgotplt->size > 0)
6635 {
6636 if (sdyn == NULL)
6637 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
6638 else
6639 bfd_put_32 (output_bfd,
6640 sdyn->output_section->vma + sdyn->output_offset,
6641 sgotplt->contents);
6642 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
6643 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
6644
6645 elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
6646 }
6647
6648 return TRUE;
6649 }
6650 \f
6651
6652 /* Set the right machine number. */
6653
6654 static bfd_boolean
6655 nds32_elf_object_p (bfd *abfd)
6656 {
6657 static unsigned int cur_arch = 0;
6658
6659 if (E_N1_ARCH != (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH))
6660 {
6661 /* E_N1_ARCH is a wild card, so it is set only when no others exist. */
6662 cur_arch = (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH);
6663 }
6664
6665 switch (cur_arch)
6666 {
6667 default:
6668 case E_N1_ARCH:
6669 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1);
6670 break;
6671 case E_N1H_ARCH:
6672 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h);
6673 break;
6674 case E_NDS_ARCH_STAR_V2_0:
6675 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v2);
6676 break;
6677 case E_NDS_ARCH_STAR_V3_0:
6678 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3);
6679 break;
6680 case E_NDS_ARCH_STAR_V3_M:
6681 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3m);
6682 break;
6683 }
6684
6685 return TRUE;
6686 }
6687
6688 /* Store the machine number in the flags field. */
6689
6690 static void
6691 nds32_elf_final_write_processing (bfd *abfd,
6692 bfd_boolean linker ATTRIBUTE_UNUSED)
6693 {
6694 unsigned long val;
6695 static unsigned int cur_mach = 0;
6696
6697 if (bfd_mach_n1 != bfd_get_mach (abfd))
6698 {
6699 cur_mach = bfd_get_mach (abfd);
6700 }
6701
6702 switch (cur_mach)
6703 {
6704 case bfd_mach_n1:
6705 /* Only happen when object is empty, since the case is abandon. */
6706 val = E_N1_ARCH;
6707 val |= E_NDS_ABI_AABI;
6708 val |= E_NDS32_ELF_VER_1_4;
6709 break;
6710 case bfd_mach_n1h:
6711 val = E_N1H_ARCH;
6712 break;
6713 case bfd_mach_n1h_v2:
6714 val = E_NDS_ARCH_STAR_V2_0;
6715 break;
6716 case bfd_mach_n1h_v3:
6717 val = E_NDS_ARCH_STAR_V3_0;
6718 break;
6719 case bfd_mach_n1h_v3m:
6720 val = E_NDS_ARCH_STAR_V3_M;
6721 break;
6722 default:
6723 val = 0;
6724 break;
6725 }
6726
6727 elf_elfheader (abfd)->e_flags &= ~EF_NDS_ARCH;
6728 elf_elfheader (abfd)->e_flags |= val;
6729 }
6730
6731 /* Function to keep NDS32 specific file flags. */
6732
6733 static bfd_boolean
6734 nds32_elf_set_private_flags (bfd *abfd, flagword flags)
6735 {
6736 BFD_ASSERT (!elf_flags_init (abfd)
6737 || elf_elfheader (abfd)->e_flags == flags);
6738
6739 elf_elfheader (abfd)->e_flags = flags;
6740 elf_flags_init (abfd) = TRUE;
6741 return TRUE;
6742 }
6743
6744 static unsigned int
6745 convert_e_flags (unsigned int e_flags, unsigned int arch)
6746 {
6747 if ((e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9)
6748 {
6749 /* From 0.9 to 1.0. */
6750 e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V1_0;
6751
6752 /* Invert E_NDS32_HAS_NO_MAC_INST. */
6753 e_flags ^= E_NDS32_HAS_NO_MAC_INST;
6754 if (arch == E_NDS_ARCH_STAR_V1_0)
6755 {
6756 /* Done. */
6757 return e_flags;
6758 }
6759 }
6760
6761 /* From 1.0 to 2.0. */
6762 e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V2_0;
6763
6764 /* Clear E_NDS32_HAS_MFUSR_PC_INST. */
6765 e_flags &= ~E_NDS32_HAS_MFUSR_PC_INST;
6766
6767 /* Invert E_NDS32_HAS_NO_MAC_INST. */
6768 e_flags ^= E_NDS32_HAS_NO_MAC_INST;
6769 return e_flags;
6770 }
6771
6772 static bfd_boolean
6773 nds32_check_vec_size (bfd *ibfd)
6774 {
6775 static unsigned int nds32_vec_size = 0;
6776
6777 asection *sec_t = NULL;
6778 bfd_byte *contents = NULL;
6779
6780 sec_t = bfd_get_section_by_name (ibfd, ".nds32_e_flags");
6781
6782 if (sec_t && sec_t->size >= 4)
6783 {
6784 /* Get vec_size in file. */
6785 unsigned int flag_t;
6786
6787 nds32_get_section_contents (ibfd, sec_t, &contents, TRUE);
6788 flag_t = bfd_get_32 (ibfd, contents);
6789
6790 /* The value could only be 4 or 16. */
6791
6792 if (!nds32_vec_size)
6793 /* Set if not set yet. */
6794 nds32_vec_size = (flag_t & 0x3);
6795 else if (nds32_vec_size != (flag_t & 0x3))
6796 {
6797 _bfd_error_handler
6798 /* xgettext:c-format */
6799 (_("%pB: ISR vector size mismatch"
6800 " with previous modules, previous %u-byte, current %u-byte"),
6801 ibfd,
6802 nds32_vec_size == 1 ? 4 : nds32_vec_size == 2 ? 16 : 0xffffffff,
6803 (flag_t & 0x3) == 1 ? 4 : (flag_t & 0x3) == 2 ? 16 : 0xffffffff);
6804 return FALSE;
6805 }
6806 else
6807 /* Only keep the first vec_size section. */
6808 sec_t->flags |= SEC_EXCLUDE;
6809 }
6810
6811 return TRUE;
6812 }
6813
6814 /* Merge backend specific data from an object file to the output
6815 object file when linking. */
6816
6817 static bfd_boolean
6818 nds32_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6819 {
6820 bfd *obfd = info->output_bfd;
6821 flagword out_flags;
6822 flagword in_flags;
6823 flagword out_16regs;
6824 flagword in_no_mac;
6825 flagword out_no_mac;
6826 flagword in_16regs;
6827 flagword out_version;
6828 flagword in_version;
6829 flagword out_fpu_config;
6830 flagword in_fpu_config;
6831
6832 /* TODO: Revise to use object-attributes instead. */
6833 if (!nds32_check_vec_size (ibfd))
6834 return FALSE;
6835
6836 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6837 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6838 return TRUE;
6839
6840 if (bfd_little_endian (ibfd) != bfd_little_endian (obfd))
6841 {
6842 _bfd_error_handler
6843 (_("%pB: warning: endian mismatch with previous modules"), ibfd);
6844
6845 bfd_set_error (bfd_error_bad_value);
6846 return FALSE;
6847 }
6848
6849 /* -B option in objcopy cannot work as expected. e_flags = 0 shall be
6850 treat as generic one without checking and merging. */
6851 if (elf_elfheader (ibfd)->e_flags)
6852 {
6853 in_version = elf_elfheader (ibfd)->e_flags & EF_NDS32_ELF_VERSION;
6854 if (in_version == E_NDS32_ELF_VER_1_2)
6855 {
6856 _bfd_error_handler
6857 (_("%pB: warning: older version of object file encountered, "
6858 "please recompile with current tool chain"), ibfd);
6859 }
6860
6861 /* We may need to merge V1 and V2 arch object files to V2. */
6862 if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6863 != (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6864 {
6865 /* Need to convert version. */
6866 if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6867 == E_NDS_ARCH_STAR_RESERVED)
6868 {
6869 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6870 }
6871 else if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6872 == E_NDS_ARCH_STAR_V3_M
6873 && (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH)
6874 == E_NDS_ARCH_STAR_V3_0)
6875 {
6876 elf_elfheader (ibfd)->e_flags =
6877 (elf_elfheader (ibfd)->e_flags & (~EF_NDS_ARCH))
6878 | E_NDS_ARCH_STAR_V3_0;
6879 }
6880 else if ((elf_elfheader (obfd)->e_flags & EF_NDS_ARCH)
6881 == E_NDS_ARCH_STAR_V0_9
6882 || (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6883 > (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6884 {
6885 elf_elfheader (obfd)->e_flags =
6886 convert_e_flags (elf_elfheader (obfd)->e_flags,
6887 (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH));
6888 }
6889 else
6890 {
6891 elf_elfheader (ibfd)->e_flags =
6892 convert_e_flags (elf_elfheader (ibfd)->e_flags,
6893 (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH));
6894 }
6895 }
6896
6897 /* Extract some flags. */
6898 in_flags = elf_elfheader (ibfd)->e_flags
6899 & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6900 | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6901
6902 /* The following flags need special treatment. */
6903 in_16regs = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6904 in_no_mac = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6905 in_fpu_config = elf_elfheader (ibfd)->e_flags & E_NDS32_FPU_REG_CONF;
6906
6907 /* Extract some flags. */
6908 out_flags = elf_elfheader (obfd)->e_flags
6909 & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6910 | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6911
6912 /* The following flags need special treatment. */
6913 out_16regs = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6914 out_no_mac = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6915 out_fpu_config = elf_elfheader (obfd)->e_flags & E_NDS32_FPU_REG_CONF;
6916 out_version = elf_elfheader (obfd)->e_flags & EF_NDS32_ELF_VERSION;
6917 if (!elf_flags_init (obfd))
6918 {
6919 /* If the input is the default architecture then do not
6920 bother setting the flags for the output architecture,
6921 instead allow future merges to do this. If no future
6922 merges ever set these flags then they will retain their
6923 unitialised values, which surprise surprise, correspond
6924 to the default values. */
6925 if (bfd_get_arch_info (ibfd)->the_default)
6926 return TRUE;
6927
6928 elf_flags_init (obfd) = TRUE;
6929 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6930
6931 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
6932 && bfd_get_arch_info (obfd)->the_default)
6933 {
6934 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
6935 bfd_get_mach (ibfd));
6936 }
6937
6938 return TRUE;
6939 }
6940
6941 /* Check flag compatibility. */
6942 if ((in_flags & EF_NDS_ABI) != (out_flags & EF_NDS_ABI))
6943 {
6944 _bfd_error_handler
6945 (_("%pB: error: ABI mismatch with previous modules"), ibfd);
6946 bfd_set_error (bfd_error_bad_value);
6947 return FALSE;
6948 }
6949
6950 if ((in_flags & EF_NDS_ARCH) != (out_flags & EF_NDS_ARCH))
6951 {
6952 if (((in_flags & EF_NDS_ARCH) != E_N1_ARCH))
6953 {
6954 _bfd_error_handler
6955 (_("%pB: error: instruction set mismatch with previous modules"),
6956 ibfd);
6957
6958 bfd_set_error (bfd_error_bad_value);
6959 return FALSE;
6960 }
6961 }
6962
6963 /* When linking with V1.2 and V1.3 objects together the output is V1.2.
6964 and perf ext1 and DIV are mergerd to perf ext1. */
6965 if (in_version == E_NDS32_ELF_VER_1_2 || out_version == E_NDS32_ELF_VER_1_2)
6966 {
6967 elf_elfheader (obfd)->e_flags =
6968 (in_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6969 | (out_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6970 | (((in_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6971 ? E_NDS32_HAS_EXT_INST : 0)
6972 | (((out_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6973 ? E_NDS32_HAS_EXT_INST : 0)
6974 | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6975 | ((in_version > out_version) ? out_version : in_version);
6976 }
6977 else
6978 {
6979 if (in_version != out_version)
6980 _bfd_error_handler
6981 /* xgettext:c-format */
6982 (_("%pB: warning: incompatible elf-versions %s and %s"),
6983 ibfd, nds32_elfver_strtab[out_version],
6984 nds32_elfver_strtab[in_version]);
6985
6986 elf_elfheader (obfd)->e_flags = in_flags | out_flags
6987 | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6988 | (in_fpu_config > out_fpu_config ? in_fpu_config : out_fpu_config)
6989 | (in_version > out_version ? out_version : in_version);
6990 }
6991 }
6992
6993 return TRUE;
6994 }
6995
6996 /* Display the flags field. */
6997
6998 static bfd_boolean
6999 nds32_elf_print_private_bfd_data (bfd *abfd, void *ptr)
7000 {
7001 FILE *file = (FILE *) ptr;
7002
7003 BFD_ASSERT (abfd != NULL && ptr != NULL);
7004
7005 _bfd_elf_print_private_bfd_data (abfd, ptr);
7006
7007 fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
7008
7009 switch (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH)
7010 {
7011 default:
7012 case E_N1_ARCH:
7013 fprintf (file, _(": n1 instructions"));
7014 break;
7015 case E_N1H_ARCH:
7016 fprintf (file, _(": n1h instructions"));
7017 break;
7018 }
7019
7020 fputc ('\n', file);
7021
7022 return TRUE;
7023 }
7024
7025 static unsigned int
7026 nds32_elf_action_discarded (asection *sec)
7027 {
7028
7029 if (strncmp
7030 (".gcc_except_table", sec->name, sizeof (".gcc_except_table") - 1) == 0)
7031 return 0;
7032
7033 return _bfd_elf_default_action_discarded (sec);
7034 }
7035
7036 static asection *
7037 nds32_elf_gc_mark_hook (asection *sec, struct bfd_link_info *info,
7038 Elf_Internal_Rela *rel, struct elf_link_hash_entry *h,
7039 Elf_Internal_Sym *sym)
7040 {
7041 if (h != NULL)
7042 switch (ELF32_R_TYPE (rel->r_info))
7043 {
7044 case R_NDS32_GNU_VTINHERIT:
7045 case R_NDS32_GNU_VTENTRY:
7046 case R_NDS32_RELA_GNU_VTINHERIT:
7047 case R_NDS32_RELA_GNU_VTENTRY:
7048 return NULL;
7049 }
7050
7051 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
7052 }
7053
7054 static enum elf_nds32_tls_type
7055 get_tls_type (enum elf_nds32_reloc_type r_type,
7056 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
7057 {
7058 enum elf_nds32_tls_type tls_type;
7059
7060 switch (r_type)
7061 {
7062 case R_NDS32_TLS_LE_HI20:
7063 case R_NDS32_TLS_LE_LO12:
7064 tls_type = GOT_TLS_LE;
7065 break;
7066 case R_NDS32_TLS_IE_HI20:
7067 case R_NDS32_TLS_IE_LO12S2:
7068 case R_NDS32_TLS_IE_LO12:
7069 tls_type = GOT_TLS_IE;
7070 break;
7071 case R_NDS32_TLS_IEGP_HI20:
7072 case R_NDS32_TLS_IEGP_LO12:
7073 case R_NDS32_TLS_IEGP_LO12S2:
7074 tls_type = GOT_TLS_IEGP;
7075 break;
7076 case R_NDS32_TLS_DESC_HI20:
7077 case R_NDS32_TLS_DESC_LO12:
7078 case R_NDS32_TLS_DESC_ADD:
7079 case R_NDS32_TLS_DESC_FUNC:
7080 case R_NDS32_TLS_DESC_CALL:
7081 tls_type = GOT_TLS_DESC;
7082 break;
7083 default:
7084 tls_type = GOT_NORMAL;
7085 break;
7086 }
7087
7088 return tls_type;
7089 }
7090
7091 /* Ensure that we have allocated bookkeeping structures for ABFD's local
7092 symbols. */
7093
7094 static bfd_boolean
7095 elf32_nds32_allocate_local_sym_info (bfd *abfd)
7096 {
7097 if (elf_local_got_refcounts (abfd) == NULL)
7098 {
7099 bfd_size_type num_syms;
7100 bfd_size_type size;
7101 char *data;
7102
7103 num_syms = elf_tdata (abfd)->symtab_hdr.sh_info;
7104 /* This space is for got_refcounts, got_tls_type, tlsdesc_gotent, and
7105 gp_offset. The details can refer to struct elf_nds32_obj_tdata. */
7106 size = num_syms * (sizeof (bfd_signed_vma) + sizeof (char)
7107 + sizeof (bfd_vma) + sizeof (int)
7108 + sizeof (bfd_boolean) + sizeof (bfd_vma));
7109 data = bfd_zalloc (abfd, size);
7110 if (data == NULL)
7111 return FALSE;
7112
7113 elf_local_got_refcounts (abfd) = (bfd_signed_vma *) data;
7114 data += num_syms * sizeof (bfd_signed_vma);
7115
7116 elf32_nds32_local_got_tls_type (abfd) = (char *) data;
7117 data += num_syms * sizeof (char);
7118
7119 elf32_nds32_local_tlsdesc_gotent (abfd) = (bfd_vma *) data;
7120 data += num_syms * sizeof (bfd_vma);
7121
7122 elf32_nds32_local_gp_offset (abfd) = (int *) data;
7123 data += num_syms * sizeof (int);
7124 }
7125
7126 return TRUE;
7127 }
7128
7129 /* Look through the relocs for a section during the first phase.
7130 Since we don't do .gots or .plts, we just need to consider the
7131 virtual table relocs for gc. */
7132
7133 static bfd_boolean
7134 nds32_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
7135 asection *sec, const Elf_Internal_Rela *relocs)
7136 {
7137 Elf_Internal_Shdr *symtab_hdr;
7138 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
7139 const Elf_Internal_Rela *rel;
7140 const Elf_Internal_Rela *rel_end;
7141 struct elf_link_hash_table *ehtab;
7142 struct elf_nds32_link_hash_table *htab;
7143 bfd *dynobj;
7144 asection *sreloc = NULL;
7145
7146 /* No need for relocation if relocatable already. */
7147 if (bfd_link_relocatable (info))
7148 {
7149 elf32_nds32_check_relax_group (abfd, sec);
7150 return TRUE;
7151 }
7152
7153 /* Don't do anything special with non-loaded, non-alloced sections.
7154 In particular, any relocs in such sections should not affect GOT
7155 and PLT reference counting (ie. we don't allow them to create GOT
7156 or PLT entries), there's no possibility or desire to optimize TLS
7157 relocs, and there's not much point in propagating relocs to shared
7158 libs that the dynamic linker won't relocate. */
7159 if ((sec->flags & SEC_ALLOC) == 0)
7160 return TRUE;
7161
7162 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7163 sym_hashes = elf_sym_hashes (abfd);
7164 sym_hashes_end =
7165 sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
7166 if (!elf_bad_symtab (abfd))
7167 sym_hashes_end -= symtab_hdr->sh_info;
7168
7169 ehtab = elf_hash_table (info);
7170 htab = nds32_elf_hash_table (info);
7171 dynobj = htab->root.dynobj;
7172
7173 rel_end = relocs + sec->reloc_count;
7174 for (rel = relocs; rel < rel_end; rel++)
7175 {
7176 enum elf_nds32_reloc_type r_type;
7177 struct elf_link_hash_entry *h;
7178 unsigned long r_symndx;
7179 enum elf_nds32_tls_type tls_type, old_tls_type;
7180
7181 r_symndx = ELF32_R_SYM (rel->r_info);
7182 r_type = ELF32_R_TYPE (rel->r_info);
7183 if (r_symndx < symtab_hdr->sh_info)
7184 h = NULL;
7185 else
7186 {
7187 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7188 while (h->root.type == bfd_link_hash_indirect
7189 || h->root.type == bfd_link_hash_warning)
7190 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7191 }
7192
7193 /* Create .got section if necessary.
7194 Some relocs require a global offset table. We create
7195 got section here, since these relocation need a got section
7196 and if it is not created yet. */
7197 if (ehtab->sgot == NULL)
7198 {
7199 switch (r_type)
7200 {
7201 case R_NDS32_GOT_HI20:
7202 case R_NDS32_GOT_LO12:
7203 case R_NDS32_GOT_LO15:
7204 case R_NDS32_GOT_LO19:
7205 case R_NDS32_GOT17S2_RELA:
7206 case R_NDS32_GOT15S2_RELA:
7207 case R_NDS32_GOTOFF:
7208 case R_NDS32_GOTOFF_HI20:
7209 case R_NDS32_GOTOFF_LO12:
7210 case R_NDS32_GOTOFF_LO15:
7211 case R_NDS32_GOTOFF_LO19:
7212 case R_NDS32_GOTPC20:
7213 case R_NDS32_GOTPC_HI20:
7214 case R_NDS32_GOTPC_LO12:
7215 case R_NDS32_GOT20:
7216 case R_NDS32_TLS_IE_HI20:
7217 case R_NDS32_TLS_IE_LO12:
7218 case R_NDS32_TLS_IE_LO12S2:
7219 case R_NDS32_TLS_IEGP_HI20:
7220 case R_NDS32_TLS_IEGP_LO12:
7221 case R_NDS32_TLS_IEGP_LO12S2:
7222 case R_NDS32_TLS_DESC_HI20:
7223 case R_NDS32_TLS_DESC_LO12:
7224 if (dynobj == NULL)
7225 htab->root.dynobj = dynobj = abfd;
7226 if (!create_got_section (dynobj, info))
7227 return FALSE;
7228 break;
7229
7230 default:
7231 break;
7232 }
7233 }
7234
7235 /* Check relocation type. */
7236 switch ((int) r_type)
7237 {
7238 case R_NDS32_GOT_HI20:
7239 case R_NDS32_GOT_LO12:
7240 case R_NDS32_GOT_LO15:
7241 case R_NDS32_GOT_LO19:
7242 case R_NDS32_GOT20:
7243 case R_NDS32_TLS_LE_HI20:
7244 case R_NDS32_TLS_LE_LO12:
7245 case R_NDS32_TLS_IE_HI20:
7246 case R_NDS32_TLS_IE_LO12:
7247 case R_NDS32_TLS_IE_LO12S2:
7248 case R_NDS32_TLS_IEGP_HI20:
7249 case R_NDS32_TLS_IEGP_LO12:
7250 case R_NDS32_TLS_IEGP_LO12S2:
7251 case R_NDS32_TLS_DESC_HI20:
7252 case R_NDS32_TLS_DESC_LO12:
7253 tls_type = get_tls_type (r_type, h);
7254 if (h)
7255 {
7256 if (tls_type != GOT_TLS_LE)
7257 h->got.refcount += 1;
7258 old_tls_type = elf32_nds32_hash_entry (h)->tls_type;
7259 }
7260 else
7261 {
7262 /* This is a global offset table entry for a local symbol. */
7263 if (!elf32_nds32_allocate_local_sym_info (abfd))
7264 return FALSE;
7265
7266 BFD_ASSERT (r_symndx < symtab_hdr->sh_info);
7267 if (tls_type != GOT_TLS_LE)
7268 elf_local_got_refcounts (abfd)[r_symndx] += 1;
7269 old_tls_type = elf32_nds32_local_got_tls_type (abfd)[r_symndx];
7270 }
7271
7272 /* We would already have issued an error message if there
7273 is a TLS/non-TLS mismatch, based on the symbol
7274 type. So just combine any TLS types needed. */
7275 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
7276 && tls_type != GOT_NORMAL)
7277 tls_type |= old_tls_type;
7278
7279 /* DESC to IE/IEGP if link to executable. */
7280 if ((tls_type & (GOT_TLS_DESC | GOT_TLS_IEGP))
7281 && (bfd_link_executable (info)))
7282 tls_type |= (bfd_link_pie (info) ? GOT_TLS_IEGP : GOT_TLS_IE);
7283
7284 if (old_tls_type != tls_type)
7285 {
7286 if (h != NULL)
7287 elf32_nds32_hash_entry (h)->tls_type = tls_type;
7288 else
7289 elf32_nds32_local_got_tls_type (abfd)[r_symndx] = tls_type;
7290 }
7291 break;
7292 case R_NDS32_9_PLTREL:
7293 case R_NDS32_25_PLTREL:
7294 case R_NDS32_PLTREL_HI20:
7295 case R_NDS32_PLTREL_LO12:
7296 case R_NDS32_PLT_GOTREL_HI20:
7297 case R_NDS32_PLT_GOTREL_LO12:
7298 case R_NDS32_PLT_GOTREL_LO15:
7299 case R_NDS32_PLT_GOTREL_LO19:
7300 case R_NDS32_PLT_GOTREL_LO20:
7301
7302 /* This symbol requires a procedure linkage table entry. We
7303 actually build the entry in adjust_dynamic_symbol,
7304 because this might be a case of linking PIC code without
7305 linking in any dynamic objects, in which case we don't
7306 need to generate a procedure linkage table after all. */
7307
7308 /* If this is a local symbol, we resolve it directly without
7309 creating a procedure linkage table entry. */
7310 if (h == NULL)
7311 continue;
7312
7313 if (h->forced_local
7314 || (bfd_link_pie (info) && h->def_regular))
7315 break;
7316
7317 elf32_nds32_hash_entry (h)->tls_type = GOT_NORMAL;
7318 h->needs_plt = 1;
7319 h->plt.refcount += 1;
7320 break;
7321
7322 case R_NDS32_16_RELA:
7323 case R_NDS32_20_RELA:
7324 case R_NDS32_5_RELA:
7325 case R_NDS32_32_RELA:
7326 case R_NDS32_HI20_RELA:
7327 case R_NDS32_LO12S3_RELA:
7328 case R_NDS32_LO12S2_RELA:
7329 case R_NDS32_LO12S2_DP_RELA:
7330 case R_NDS32_LO12S2_SP_RELA:
7331 case R_NDS32_LO12S1_RELA:
7332 case R_NDS32_LO12S0_RELA:
7333 case R_NDS32_LO12S0_ORI_RELA:
7334 case R_NDS32_SDA16S3_RELA:
7335 case R_NDS32_SDA17S2_RELA:
7336 case R_NDS32_SDA18S1_RELA:
7337 case R_NDS32_SDA19S0_RELA:
7338 case R_NDS32_SDA15S3_RELA:
7339 case R_NDS32_SDA15S2_RELA:
7340 case R_NDS32_SDA12S2_DP_RELA:
7341 case R_NDS32_SDA12S2_SP_RELA:
7342 case R_NDS32_SDA15S1_RELA:
7343 case R_NDS32_SDA15S0_RELA:
7344 case R_NDS32_SDA_FP7U2_RELA:
7345 case R_NDS32_15_PCREL_RELA:
7346 case R_NDS32_17_PCREL_RELA:
7347 case R_NDS32_25_PCREL_RELA:
7348
7349 if (h != NULL && !bfd_link_pic (info))
7350 {
7351 h->non_got_ref = 1;
7352 h->plt.refcount += 1;
7353 }
7354
7355 /* If we are creating a shared library, and this is a reloc against
7356 a global symbol, or a non PC relative reloc against a local
7357 symbol, then we need to copy the reloc into the shared library.
7358 However, if we are linking with -Bsymbolic, we do not need to
7359 copy a reloc against a global symbol which is defined in an
7360 object we are including in the link (i.e., DEF_REGULAR is set).
7361 At this point we have not seen all the input files, so it is
7362 possible that DEF_REGULAR is not set now but will be set later
7363 (it is never cleared). We account for that possibility below by
7364 storing information in the dyn_relocs field of the hash table
7365 entry. A similar situation occurs when creating shared libraries
7366 and symbol visibility changes render the symbol local.
7367
7368 If on the other hand, we are creating an executable, we may need
7369 to keep relocations for symbols satisfied by a dynamic library
7370 if we manage to avoid copy relocs for the symbol. */
7371 if ((bfd_link_pic (info)
7372 && (sec->flags & SEC_ALLOC) != 0
7373 && ((r_type != R_NDS32_25_PCREL_RELA
7374 && r_type != R_NDS32_15_PCREL_RELA
7375 && r_type != R_NDS32_17_PCREL_RELA
7376 && !(r_type == R_NDS32_32_RELA
7377 && strcmp (sec->name, ".eh_frame") == 0))
7378 || (h != NULL
7379 && (!info->symbolic
7380 || h->root.type == bfd_link_hash_defweak
7381 || !h->def_regular))))
7382 || (!bfd_link_pic (info)
7383 && (sec->flags & SEC_ALLOC) != 0
7384 && h != NULL
7385 && (h->root.type == bfd_link_hash_defweak
7386 || !h->def_regular)))
7387 {
7388 struct elf_dyn_relocs *p;
7389 struct elf_dyn_relocs **head;
7390
7391 if (dynobj == NULL)
7392 htab->root.dynobj = dynobj = abfd;
7393
7394 /* When creating a shared object, we must copy these
7395 relocs into the output file. We create a reloc
7396 section in dynobj and make room for the reloc. */
7397 if (sreloc == NULL)
7398 {
7399 const char *name;
7400
7401 name = bfd_elf_string_from_elf_section
7402 (abfd, elf_elfheader (abfd)->e_shstrndx,
7403 elf_section_data (sec)->rela.hdr->sh_name);
7404 if (name == NULL)
7405 return FALSE;
7406
7407 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
7408 && strcmp (bfd_get_section_name (abfd, sec),
7409 name + 5) == 0);
7410
7411 sreloc = bfd_get_section_by_name (dynobj, name);
7412 if (sreloc == NULL)
7413 {
7414 flagword flags;
7415
7416 sreloc = bfd_make_section (dynobj, name);
7417 flags = (SEC_HAS_CONTENTS | SEC_READONLY
7418 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
7419 if ((sec->flags & SEC_ALLOC) != 0)
7420 flags |= SEC_ALLOC | SEC_LOAD;
7421 if (sreloc == NULL
7422 || !bfd_set_section_flags (dynobj, sreloc, flags)
7423 || !bfd_set_section_alignment (dynobj, sreloc, 2))
7424 return FALSE;
7425
7426 elf_section_type (sreloc) = SHT_RELA;
7427 }
7428 elf_section_data (sec)->sreloc = sreloc;
7429 }
7430
7431 /* If this is a global symbol, we count the number of
7432 relocations we need for this symbol. */
7433 if (h != NULL)
7434 head = &((struct elf_nds32_link_hash_entry *) h)->dyn_relocs;
7435 else
7436 {
7437 asection *s;
7438 void *vpp;
7439
7440 Elf_Internal_Sym *isym;
7441 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx);
7442 if (isym == NULL)
7443 return FALSE;
7444
7445 /* Track dynamic relocs needed for local syms too. */
7446 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
7447 if (s == NULL)
7448 return FALSE;
7449
7450 vpp = &elf_section_data (s)->local_dynrel;
7451 head = (struct elf_dyn_relocs **) vpp;
7452 }
7453
7454 p = *head;
7455 if (p == NULL || p->sec != sec)
7456 {
7457 bfd_size_type amt = sizeof (*p);
7458 p = (struct elf_dyn_relocs *) bfd_alloc (dynobj, amt);
7459 if (p == NULL)
7460 return FALSE;
7461 p->next = *head;
7462 *head = p;
7463 p->sec = sec;
7464 p->count = 0;
7465 p->pc_count = 0;
7466 }
7467
7468 p->count += 1;
7469
7470 /* Since eh_frame is readonly, R_NDS32_32_RELA
7471 reloc for eh_frame will cause shared library has
7472 TEXTREL entry in the dynamic section. This lead glibc
7473 testsuites to failure (bug-13092) and cause kernel fail
7474 (bug-11819). I think the best solution is to replace
7475 absolute reloc with pc relative reloc in the eh_frame.
7476 To do that, we need to support the following issues:
7477
7478 === For GCC ===
7479 * gcc/config/nds32/nds32.h: Define
7480 ASM_PREFERRED_EH_DATA_FORMAT to encode DW_EH_PE_pcrel
7481 and DW_EH_PE_sdata4 into DWARF exception header when
7482 option have '-fpic'.
7483
7484 === For binutils ===
7485 * bfd/: Define new reloc R_NDS32_32_PCREL_RELA.
7486 * gas/config/tc-nds32.h: Define DIFF_EXPR_OK. This
7487 may break our nds DIFF mechanism, therefore, we
7488 must disable all linker relaxations to ensure
7489 correctness.
7490 * gas/config/tc-nds32.c (nds32_apply_fix): Replace
7491 R_NDS32_32_RELA with R_NDS32_32_PCREL_RELA, and
7492 do the necessary modification.
7493
7494 Unfortunately, it still have some problems for nds32
7495 to support pc relative reloc in the eh_frame. So I use
7496 another solution to fix this issue.
7497
7498 However, I find that ld always emit TEXTREL marker for
7499 R_NDS32_NONE relocs in rel.dyn. These none relocs are
7500 correspond to R_NDS32_32_RELA for .eh_frame section.
7501 It means that we always reserve redundant entries of rel.dyn
7502 for these relocs which actually do nothing in dynamic linker.
7503
7504 Therefore, we regard these relocs as pc relative relocs
7505 here and increase the pc_count. */
7506 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA
7507 || ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
7508 || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA
7509 || (r_type == R_NDS32_32_RELA
7510 && strcmp (sec->name, ".eh_frame") == 0))
7511 p->pc_count += 1;
7512 }
7513 break;
7514
7515 /* This relocation describes the C++ object vtable hierarchy.
7516 Reconstruct it for later use during GC. */
7517 case R_NDS32_RELA_GNU_VTINHERIT:
7518 case R_NDS32_GNU_VTINHERIT:
7519 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
7520 return FALSE;
7521 break;
7522
7523 /* This relocation describes which C++ vtable entries are actually
7524 used. Record for later use during GC. */
7525 case R_NDS32_GNU_VTENTRY:
7526 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
7527 return FALSE;
7528 break;
7529 case R_NDS32_RELA_GNU_VTENTRY:
7530 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
7531 return FALSE;
7532 break;
7533 }
7534 }
7535
7536 return TRUE;
7537 }
7538
7539 /* Write VAL in uleb128 format to P, returning a pointer to the
7540 following byte.
7541 This code is copied from elf-attr.c. */
7542
7543 static bfd_byte *
7544 write_uleb128 (bfd_byte *p, unsigned int val)
7545 {
7546 bfd_byte c;
7547 do
7548 {
7549 c = val & 0x7f;
7550 val >>= 7;
7551 if (val)
7552 c |= 0x80;
7553 *(p++) = c;
7554 }
7555 while (val);
7556 return p;
7557 }
7558
7559 static bfd_signed_vma
7560 calculate_offset (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
7561 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr)
7562 {
7563 bfd_signed_vma foff;
7564 bfd_vma symval, addend;
7565 asection *sym_sec;
7566
7567 /* Get the value of the symbol referred to by the reloc. */
7568 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
7569 {
7570 Elf_Internal_Sym *isym;
7571
7572 /* A local symbol. */
7573 isym = isymbuf + ELF32_R_SYM (irel->r_info);
7574
7575 if (isym->st_shndx == SHN_UNDEF)
7576 sym_sec = bfd_und_section_ptr;
7577 else if (isym->st_shndx == SHN_ABS)
7578 sym_sec = bfd_abs_section_ptr;
7579 else if (isym->st_shndx == SHN_COMMON)
7580 sym_sec = bfd_com_section_ptr;
7581 else
7582 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
7583 symval = isym->st_value + sym_sec->output_section->vma
7584 + sym_sec->output_offset;
7585 }
7586 else
7587 {
7588 unsigned long indx;
7589 struct elf_link_hash_entry *h;
7590
7591 /* An external symbol. */
7592 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
7593 h = elf_sym_hashes (abfd)[indx];
7594 BFD_ASSERT (h != NULL);
7595
7596 if (h->root.type != bfd_link_hash_defined
7597 && h->root.type != bfd_link_hash_defweak)
7598 /* This appears to be a reference to an undefined
7599 symbol. Just ignore it--it will be caught by the
7600 regular reloc processing. */
7601 return 0;
7602
7603 if (h->root.u.def.section->flags & SEC_MERGE)
7604 {
7605 sym_sec = h->root.u.def.section;
7606 symval = _bfd_merged_section_offset (abfd, &sym_sec,
7607 elf_section_data (sym_sec)->sec_info,
7608 h->root.u.def.value);
7609 symval = symval + sym_sec->output_section->vma
7610 + sym_sec->output_offset;
7611 }
7612 else
7613 symval = (h->root.u.def.value
7614 + h->root.u.def.section->output_section->vma
7615 + h->root.u.def.section->output_offset);
7616 }
7617
7618 addend = irel->r_addend;
7619
7620 foff = (symval + addend
7621 - (irel->r_offset + sec->output_section->vma + sec->output_offset));
7622 return foff;
7623 }
7624 \f
7625
7626 /* Convert a 32-bit instruction to 16-bit one.
7627 INSN is the input 32-bit instruction, INSN16 is the output 16-bit
7628 instruction. If INSN_TYPE is not NULL, it the CGEN instruction
7629 type of INSN16. Return 1 if successful. */
7630
7631 static int
7632 nds32_convert_32_to_16_alu1 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7633 int *pinsn_type)
7634 {
7635 uint16_t insn16 = 0;
7636 int insn_type = 0;
7637 unsigned long mach = bfd_get_mach (abfd);
7638
7639 if (N32_SH5 (insn) != 0)
7640 return 0;
7641
7642 switch (N32_SUB5 (insn))
7643 {
7644 case N32_ALU1_ADD_SLLI:
7645 case N32_ALU1_ADD_SRLI:
7646 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
7647 {
7648 insn16 = N16_TYPE333 (ADD333, N32_RT5 (insn), N32_RA5 (insn),
7649 N32_RB5 (insn));
7650 insn_type = NDS32_INSN_ADD333;
7651 }
7652 else if (N32_IS_RT4 (insn))
7653 {
7654 if (N32_RT5 (insn) == N32_RA5 (insn))
7655 insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RB5 (insn));
7656 else if (N32_RT5 (insn) == N32_RB5 (insn))
7657 insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RA5 (insn));
7658 insn_type = NDS32_INSN_ADD45;
7659 }
7660 break;
7661
7662 case N32_ALU1_SUB_SLLI:
7663 case N32_ALU1_SUB_SRLI:
7664 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
7665 {
7666 insn16 = N16_TYPE333 (SUB333, N32_RT5 (insn), N32_RA5 (insn),
7667 N32_RB5 (insn));
7668 insn_type = NDS32_INSN_SUB333;
7669 }
7670 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
7671 {
7672 insn16 = N16_TYPE45 (SUB45, N32_RT54 (insn), N32_RB5 (insn));
7673 insn_type = NDS32_INSN_SUB45;
7674 }
7675 break;
7676
7677 case N32_ALU1_AND_SLLI:
7678 case N32_ALU1_AND_SRLI:
7679 /* and $rt, $rt, $rb -> and33 for v3, v3m. */
7680 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7681 && N32_IS_RB3 (insn))
7682 {
7683 if (N32_RT5 (insn) == N32_RA5 (insn))
7684 insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RB5 (insn));
7685 else if (N32_RT5 (insn) == N32_RB5 (insn))
7686 insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RA5 (insn));
7687 if (insn16)
7688 insn_type = NDS32_INSN_AND33;
7689 }
7690 break;
7691
7692 case N32_ALU1_XOR_SLLI:
7693 case N32_ALU1_XOR_SRLI:
7694 /* xor $rt, $rt, $rb -> xor33 for v3, v3m. */
7695 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7696 && N32_IS_RB3 (insn))
7697 {
7698 if (N32_RT5 (insn) == N32_RA5 (insn))
7699 insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RB5 (insn));
7700 else if (N32_RT5 (insn) == N32_RB5 (insn))
7701 insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RA5 (insn));
7702 if (insn16)
7703 insn_type = NDS32_INSN_XOR33;
7704 }
7705 break;
7706
7707 case N32_ALU1_OR_SLLI:
7708 case N32_ALU1_OR_SRLI:
7709 /* or $rt, $rt, $rb -> or33 for v3, v3m. */
7710 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7711 && N32_IS_RB3 (insn))
7712 {
7713 if (N32_RT5 (insn) == N32_RA5 (insn))
7714 insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RB5 (insn));
7715 else if (N32_RT5 (insn) == N32_RB5 (insn))
7716 insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RA5 (insn));
7717 if (insn16)
7718 insn_type = NDS32_INSN_OR33;
7719 }
7720 break;
7721 case N32_ALU1_NOR:
7722 /* nor $rt, $ra, $ra -> not33 for v3, v3m. */
7723 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RB3 (insn)
7724 && N32_RA5 (insn) == N32_RB5 (insn))
7725 {
7726 insn16 = N16_MISC33 (NOT33, N32_RT5 (insn), N32_RA5 (insn));
7727 insn_type = NDS32_INSN_NOT33;
7728 }
7729 break;
7730 case N32_ALU1_SRAI:
7731 if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
7732 {
7733 insn16 = N16_TYPE45 (SRAI45, N32_RT54 (insn), N32_UB5 (insn));
7734 insn_type = NDS32_INSN_SRAI45;
7735 }
7736 break;
7737
7738 case N32_ALU1_SRLI:
7739 if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
7740 {
7741 insn16 = N16_TYPE45 (SRLI45, N32_RT54 (insn), N32_UB5 (insn));
7742 insn_type = NDS32_INSN_SRLI45;
7743 }
7744 break;
7745
7746 case N32_ALU1_SLLI:
7747 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_UB5 (insn) < 8)
7748 {
7749 insn16 = N16_TYPE333 (SLLI333, N32_RT5 (insn), N32_RA5 (insn),
7750 N32_UB5 (insn));
7751 insn_type = NDS32_INSN_SLLI333;
7752 }
7753 break;
7754
7755 case N32_ALU1_ZEH:
7756 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7757 {
7758 insn16 = N16_BFMI333 (ZEH33, N32_RT5 (insn), N32_RA5 (insn));
7759 insn_type = NDS32_INSN_ZEH33;
7760 }
7761 break;
7762
7763 case N32_ALU1_SEB:
7764 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7765 {
7766 insn16 = N16_BFMI333 (SEB33, N32_RT5 (insn), N32_RA5 (insn));
7767 insn_type = NDS32_INSN_SEB33;
7768 }
7769 break;
7770
7771 case N32_ALU1_SEH:
7772 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7773 {
7774 insn16 = N16_BFMI333 (SEH33, N32_RT5 (insn), N32_RA5 (insn));
7775 insn_type = NDS32_INSN_SEH33;
7776 }
7777 break;
7778
7779 case N32_ALU1_SLT:
7780 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7781 {
7782 /* Implicit r15. */
7783 insn16 = N16_TYPE45 (SLT45, N32_RA54 (insn), N32_RB5 (insn));
7784 insn_type = NDS32_INSN_SLT45;
7785 }
7786 break;
7787
7788 case N32_ALU1_SLTS:
7789 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7790 {
7791 /* Implicit r15. */
7792 insn16 = N16_TYPE45 (SLTS45, N32_RA54 (insn), N32_RB5 (insn));
7793 insn_type = NDS32_INSN_SLTS45;
7794 }
7795 break;
7796 }
7797
7798 if ((insn16 & 0x8000) == 0)
7799 return 0;
7800
7801 if (pinsn16)
7802 *pinsn16 = insn16;
7803 if (pinsn_type)
7804 *pinsn_type = insn_type;
7805 return 1;
7806 }
7807
7808 static int
7809 nds32_convert_32_to_16_alu2 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7810 int *pinsn_type)
7811 {
7812 uint16_t insn16 = 0;
7813 int insn_type;
7814 unsigned long mach = bfd_get_mach (abfd);
7815
7816 /* TODO: bset, bclr, btgl, btst. */
7817 if (__GF (insn, 6, 4) != 0)
7818 return 0;
7819
7820 switch (N32_IMMU (insn, 6))
7821 {
7822 case N32_ALU2_MUL:
7823 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7824 && N32_IS_RB3 (insn))
7825 {
7826 if (N32_RT5 (insn) == N32_RA5 (insn))
7827 insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RB5 (insn));
7828 else if (N32_RT5 (insn) == N32_RB5 (insn))
7829 insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RA5 (insn));
7830 if (insn16)
7831 insn_type = NDS32_INSN_MUL33;
7832 }
7833 }
7834
7835 if ((insn16 & 0x8000) == 0)
7836 return 0;
7837
7838 if (pinsn16)
7839 *pinsn16 = insn16;
7840 if (pinsn_type)
7841 *pinsn_type = insn_type;
7842 return 1;
7843 }
7844
7845 int
7846 nds32_convert_32_to_16 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7847 int *pinsn_type)
7848 {
7849 int op6;
7850 uint16_t insn16 = 0;
7851 int insn_type = 0;
7852 unsigned long mach = bfd_get_mach (abfd);
7853
7854 /* Decode 32-bit instruction. */
7855 if (insn & 0x80000000)
7856 {
7857 /* Not 32-bit insn. */
7858 return 0;
7859 }
7860
7861 op6 = N32_OP6 (insn);
7862
7863 /* Convert it to 16-bit instruction. */
7864 switch (op6)
7865 {
7866 case N32_OP6_MOVI:
7867 if (IS_WITHIN_S (N32_IMM20S (insn), 5))
7868 {
7869 insn16 = N16_TYPE55 (MOVI55, N32_RT5 (insn), N32_IMM20S (insn));
7870 insn_type = NDS32_INSN_MOVI55;
7871 }
7872 else if (mach >= MACH_V3 && N32_IMM20S (insn) >= 16
7873 && N32_IMM20S (insn) < 48 && N32_IS_RT4 (insn))
7874 {
7875 insn16 = N16_TYPE45 (MOVPI45, N32_RT54 (insn),
7876 N32_IMM20S (insn) - 16);
7877 insn_type = NDS32_INSN_MOVPI45;
7878 }
7879 break;
7880
7881 case N32_OP6_ADDI:
7882 if (N32_IMM15S (insn) == 0)
7883 {
7884 /* Do not convert `addi $sp, $sp, 0' to `mov55 $sp, $sp',
7885 because `mov55 $sp, $sp' is ifret16 in V3 ISA. */
7886 if (mach <= MACH_V2
7887 || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7888 {
7889 insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7890 insn_type = NDS32_INSN_MOV55;
7891 }
7892 }
7893 else if (N32_IMM15S (insn) > 0)
7894 {
7895 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) < 8)
7896 {
7897 insn16 = N16_TYPE333 (ADDI333, N32_RT5 (insn), N32_RA5 (insn),
7898 N32_IMM15S (insn));
7899 insn_type = NDS32_INSN_ADDI333;
7900 }
7901 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7902 && N32_IMM15S (insn) < 32)
7903 {
7904 insn16 = N16_TYPE45 (ADDI45, N32_RT54 (insn), N32_IMM15S (insn));
7905 insn_type = NDS32_INSN_ADDI45;
7906 }
7907 else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7908 && N32_RT5 (insn) == N32_RA5 (insn)
7909 && N32_IMM15S (insn) < 512)
7910 {
7911 insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7912 insn_type = NDS32_INSN_ADDI10_SP;
7913 }
7914 else if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7915 && N32_RA5 (insn) == REG_SP && N32_IMM15S (insn) < 256
7916 && (N32_IMM15S (insn) % 4 == 0))
7917 {
7918 insn16 = N16_TYPE36 (ADDRI36_SP, N32_RT5 (insn),
7919 N32_IMM15S (insn) >> 2);
7920 insn_type = NDS32_INSN_ADDRI36_SP;
7921 }
7922 }
7923 else
7924 {
7925 /* Less than 0. */
7926 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) > -8)
7927 {
7928 insn16 = N16_TYPE333 (SUBI333, N32_RT5 (insn), N32_RA5 (insn),
7929 0 - N32_IMM15S (insn));
7930 insn_type = NDS32_INSN_SUBI333;
7931 }
7932 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7933 && N32_IMM15S (insn) > -32)
7934 {
7935 insn16 = N16_TYPE45 (SUBI45, N32_RT54 (insn),
7936 0 - N32_IMM15S (insn));
7937 insn_type = NDS32_INSN_SUBI45;
7938 }
7939 else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7940 && N32_RT5 (insn) == N32_RA5 (insn)
7941 && N32_IMM15S (insn) >= -512)
7942 {
7943 insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7944 insn_type = NDS32_INSN_ADDI10_SP;
7945 }
7946 }
7947 break;
7948
7949 case N32_OP6_ORI:
7950 if (N32_IMM15S (insn) == 0)
7951 {
7952 /* Do not convert `ori $sp, $sp, 0' to `mov55 $sp, $sp',
7953 because `mov55 $sp, $sp' is ifret16 in V3 ISA. */
7954 if (mach <= MACH_V2
7955 || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7956 {
7957 insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7958 insn_type = NDS32_INSN_MOV55;
7959 }
7960 }
7961 break;
7962
7963 case N32_OP6_SUBRI:
7964 if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7965 && N32_IS_RA3 (insn) && N32_IMM15S (insn) == 0)
7966 {
7967 insn16 = N16_MISC33 (NEG33, N32_RT5 (insn), N32_RA5 (insn));
7968 insn_type = NDS32_INSN_NEG33;
7969 }
7970 break;
7971
7972 case N32_OP6_ANDI:
7973 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7974 {
7975 if (N32_IMM15U (insn) == 1)
7976 {
7977 insn16 = N16_BFMI333 (XLSB33, N32_RT5 (insn), N32_RA5 (insn));
7978 insn_type = NDS32_INSN_XLSB33;
7979 }
7980 else if (N32_IMM15U (insn) == 0x7ff)
7981 {
7982 insn16 = N16_BFMI333 (X11B33, N32_RT5 (insn), N32_RA5 (insn));
7983 insn_type = NDS32_INSN_X11B33;
7984 }
7985 else if (N32_IMM15U (insn) == 0xff)
7986 {
7987 insn16 = N16_BFMI333 (ZEB33, N32_RT5 (insn), N32_RA5 (insn));
7988 insn_type = NDS32_INSN_ZEB33;
7989 }
7990 else if (mach >= MACH_V3 && N32_RT5 (insn) == N32_RA5 (insn)
7991 && N32_IMM15U (insn) < 256)
7992 {
7993 int imm15u = N32_IMM15U (insn);
7994
7995 if (__builtin_popcount (imm15u) == 1)
7996 {
7997 /* BMSKI33 */
7998 int imm3u = __builtin_ctz (imm15u);
7999
8000 insn16 = N16_BFMI333 (BMSKI33, N32_RT5 (insn), imm3u);
8001 insn_type = NDS32_INSN_BMSKI33;
8002 }
8003 else if (imm15u != 0 && __builtin_popcount (imm15u + 1) == 1)
8004 {
8005 /* FEXTI33 */
8006 int imm3u = __builtin_ctz (imm15u + 1) - 1;
8007
8008 insn16 = N16_BFMI333 (FEXTI33, N32_RT5 (insn), imm3u);
8009 insn_type = NDS32_INSN_FEXTI33;
8010 }
8011 }
8012 }
8013 break;
8014
8015 case N32_OP6_SLTI:
8016 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
8017 && IS_WITHIN_U (N32_IMM15S (insn), 5))
8018 {
8019 insn16 = N16_TYPE45 (SLTI45, N32_RA54 (insn), N32_IMM15S (insn));
8020 insn_type = NDS32_INSN_SLTI45;
8021 }
8022 break;
8023
8024 case N32_OP6_SLTSI:
8025 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
8026 && IS_WITHIN_U (N32_IMM15S (insn), 5))
8027 {
8028 insn16 = N16_TYPE45 (SLTSI45, N32_RA54 (insn), N32_IMM15S (insn));
8029 insn_type = NDS32_INSN_SLTSI45;
8030 }
8031 break;
8032
8033 case N32_OP6_LWI:
8034 if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
8035 {
8036 insn16 = N16_TYPE45 (LWI450, N32_RT54 (insn), N32_RA5 (insn));
8037 insn_type = NDS32_INSN_LWI450;
8038 }
8039 else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8040 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8041 {
8042 insn16 = N16_TYPE333 (LWI333, N32_RT5 (insn), N32_RA5 (insn),
8043 N32_IMM15S (insn));
8044 insn_type = NDS32_INSN_LWI333;
8045 }
8046 else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
8047 && IS_WITHIN_U (N32_IMM15S (insn), 7))
8048 {
8049 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
8050 insn_type = NDS32_INSN_LWI37;
8051 }
8052 else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
8053 && IS_WITHIN_U (N32_IMM15S (insn), 7))
8054 {
8055 insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 0, N32_IMM15S (insn));
8056 insn_type = NDS32_INSN_LWI37_SP;
8057 }
8058 else if (mach >= MACH_V2 && N32_IS_RT4 (insn) && N32_RA5 (insn) == REG_R8
8059 && -32 <= N32_IMM15S (insn) && N32_IMM15S (insn) < 0)
8060 {
8061 insn16 = N16_TYPE45 (LWI45_FE, N32_RT54 (insn),
8062 N32_IMM15S (insn) + 32);
8063 insn_type = NDS32_INSN_LWI45_FE;
8064 }
8065 break;
8066
8067 case N32_OP6_SWI:
8068 if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
8069 {
8070 insn16 = N16_TYPE45 (SWI450, N32_RT54 (insn), N32_RA5 (insn));
8071 insn_type = NDS32_INSN_SWI450;
8072 }
8073 else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8074 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8075 {
8076 insn16 = N16_TYPE333 (SWI333, N32_RT5 (insn), N32_RA5 (insn),
8077 N32_IMM15S (insn));
8078 insn_type = NDS32_INSN_SWI333;
8079 }
8080 else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
8081 && IS_WITHIN_U (N32_IMM15S (insn), 7))
8082 {
8083 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
8084 insn_type = NDS32_INSN_SWI37;
8085 }
8086 else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
8087 && IS_WITHIN_U (N32_IMM15S (insn), 7))
8088 {
8089 insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 1, N32_IMM15S (insn));
8090 insn_type = NDS32_INSN_SWI37_SP;
8091 }
8092 break;
8093
8094 case N32_OP6_LWI_BI:
8095 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8096 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8097 {
8098 insn16 = N16_TYPE333 (LWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
8099 N32_IMM15S (insn));
8100 insn_type = NDS32_INSN_LWI333_BI;
8101 }
8102 break;
8103
8104 case N32_OP6_SWI_BI:
8105 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8106 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8107 {
8108 insn16 = N16_TYPE333 (SWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
8109 N32_IMM15S (insn));
8110 insn_type = NDS32_INSN_SWI333_BI;
8111 }
8112 break;
8113
8114 case N32_OP6_LHI:
8115 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8116 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8117 {
8118 insn16 = N16_TYPE333 (LHI333, N32_RT5 (insn), N32_RA5 (insn),
8119 N32_IMM15S (insn));
8120 insn_type = NDS32_INSN_LHI333;
8121 }
8122 break;
8123
8124 case N32_OP6_SHI:
8125 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8126 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8127 {
8128 insn16 = N16_TYPE333 (SHI333, N32_RT5 (insn), N32_RA5 (insn),
8129 N32_IMM15S (insn));
8130 insn_type = NDS32_INSN_SHI333;
8131 }
8132 break;
8133
8134 case N32_OP6_LBI:
8135 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8136 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8137 {
8138 insn16 = N16_TYPE333 (LBI333, N32_RT5 (insn), N32_RA5 (insn),
8139 N32_IMM15S (insn));
8140 insn_type = NDS32_INSN_LBI333;
8141 }
8142 break;
8143
8144 case N32_OP6_SBI:
8145 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8146 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8147 {
8148 insn16 = N16_TYPE333 (SBI333, N32_RT5 (insn), N32_RA5 (insn),
8149 N32_IMM15S (insn));
8150 insn_type = NDS32_INSN_SBI333;
8151 }
8152 break;
8153
8154 case N32_OP6_ALU1:
8155 return nds32_convert_32_to_16_alu1 (abfd, insn, pinsn16, pinsn_type);
8156
8157 case N32_OP6_ALU2:
8158 return nds32_convert_32_to_16_alu2 (abfd, insn, pinsn16, pinsn_type);
8159
8160 case N32_OP6_BR1:
8161 if (!IS_WITHIN_S (N32_IMM14S (insn), 8))
8162 goto done;
8163
8164 if ((insn & N32_BIT (14)) == 0)
8165 {
8166 /* N32_BR1_BEQ */
8167 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
8168 && N32_RT5 (insn) != REG_R5)
8169 insn16 = N16_TYPE38 (BEQS38, N32_RT5 (insn), N32_IMM14S (insn));
8170 else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
8171 && N32_RA5 (insn) != REG_R5)
8172 insn16 = N16_TYPE38 (BEQS38, N32_RA5 (insn), N32_IMM14S (insn));
8173 insn_type = NDS32_INSN_BEQS38;
8174 break;
8175 }
8176 else
8177 {
8178 /* N32_BR1_BNE */
8179 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
8180 && N32_RT5 (insn) != REG_R5)
8181 insn16 = N16_TYPE38 (BNES38, N32_RT5 (insn), N32_IMM14S (insn));
8182 else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
8183 && N32_RA5 (insn) != REG_R5)
8184 insn16 = N16_TYPE38 (BNES38, N32_RA5 (insn), N32_IMM14S (insn));
8185 insn_type = NDS32_INSN_BNES38;
8186 break;
8187 }
8188 break;
8189
8190 case N32_OP6_BR2:
8191 switch (N32_BR2_SUB (insn))
8192 {
8193 case N32_BR2_BEQZ:
8194 if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
8195 {
8196 insn16 = N16_TYPE38 (BEQZ38, N32_RT5 (insn), N32_IMM16S (insn));
8197 insn_type = NDS32_INSN_BEQZ38;
8198 }
8199 else if (N32_RT5 (insn) == REG_R15
8200 && IS_WITHIN_S (N32_IMM16S (insn), 8))
8201 {
8202 insn16 = N16_TYPE8 (BEQZS8, N32_IMM16S (insn));
8203 insn_type = NDS32_INSN_BEQZS8;
8204 }
8205 break;
8206
8207 case N32_BR2_BNEZ:
8208 if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
8209 {
8210 insn16 = N16_TYPE38 (BNEZ38, N32_RT5 (insn), N32_IMM16S (insn));
8211 insn_type = NDS32_INSN_BNEZ38;
8212 }
8213 else if (N32_RT5 (insn) == REG_R15
8214 && IS_WITHIN_S (N32_IMM16S (insn), 8))
8215 {
8216 insn16 = N16_TYPE8 (BNEZS8, N32_IMM16S (insn));
8217 insn_type = NDS32_INSN_BNEZS8;
8218 }
8219 break;
8220
8221 case N32_BR2_SOP0:
8222 if (__GF (insn, 20, 5) == 0 && IS_WITHIN_U (N32_IMM16S (insn), 9))
8223 {
8224 insn16 = N16_TYPE9 (IFCALL9, N32_IMM16S (insn));
8225 insn_type = NDS32_INSN_IFCALL9;
8226 }
8227 break;
8228 }
8229 break;
8230
8231 case N32_OP6_JI:
8232 if ((insn & N32_BIT (24)) == 0)
8233 {
8234 /* N32_JI_J */
8235 if (IS_WITHIN_S (N32_IMM24S (insn), 8))
8236 {
8237 insn16 = N16_TYPE8 (J8, N32_IMM24S (insn));
8238 insn_type = NDS32_INSN_J8;
8239 }
8240 }
8241 break;
8242
8243 case N32_OP6_JREG:
8244 if (__GF (insn, 8, 2) != 0)
8245 goto done;
8246
8247 switch (N32_IMMU (insn, 5))
8248 {
8249 case N32_JREG_JR:
8250 if (N32_JREG_HINT (insn) == 0)
8251 {
8252 /* jr */
8253 insn16 = N16_TYPE5 (JR5, N32_RB5 (insn));
8254 insn_type = NDS32_INSN_JR5;
8255 }
8256 else if (N32_JREG_HINT (insn) == 1)
8257 {
8258 /* ret */
8259 insn16 = N16_TYPE5 (RET5, N32_RB5 (insn));
8260 insn_type = NDS32_INSN_RET5;
8261 }
8262 else if (N32_JREG_HINT (insn) == 3)
8263 {
8264 /* ifret = mov55 $sp, $sp */
8265 insn16 = N16_TYPE55 (MOV55, REG_SP, REG_SP);
8266 insn_type = NDS32_INSN_IFRET;
8267 }
8268 break;
8269
8270 case N32_JREG_JRAL:
8271 /* It's convertible when return rt5 is $lp and address
8272 translation is kept. */
8273 if (N32_RT5 (insn) == REG_LP && N32_JREG_HINT (insn) == 0)
8274 {
8275 insn16 = N16_TYPE5 (JRAL5, N32_RB5 (insn));
8276 insn_type = NDS32_INSN_JRAL5;
8277 }
8278 break;
8279 }
8280 break;
8281
8282 case N32_OP6_MISC:
8283 if (N32_SUB5 (insn) == N32_MISC_BREAK && N32_SWID (insn) < 32)
8284 {
8285 /* For v3, swid above 31 are used for ex9.it. */
8286 insn16 = N16_TYPE5 (BREAK16, N32_SWID (insn));
8287 insn_type = NDS32_INSN_BREAK16;
8288 }
8289 break;
8290
8291 default:
8292 /* This instruction has no 16-bit variant. */
8293 goto done;
8294 }
8295
8296 done:
8297 /* Bit-15 of insn16 should be set for a valid instruction. */
8298 if ((insn16 & 0x8000) == 0)
8299 return 0;
8300
8301 if (pinsn16)
8302 *pinsn16 = insn16;
8303 if (pinsn_type)
8304 *pinsn_type = insn_type;
8305 return 1;
8306 }
8307
8308 static int
8309 special_convert_32_to_16 (unsigned long insn, uint16_t *pinsn16,
8310 Elf_Internal_Rela *reloc)
8311 {
8312 uint16_t insn16 = 0;
8313
8314 if ((reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG) == 0
8315 || (ELF32_R_TYPE (reloc->r_info) != R_NDS32_INSN16))
8316 return 0;
8317
8318 if (!N32_IS_RT3 (insn))
8319 return 0;
8320
8321 switch (N32_OP6 (insn))
8322 {
8323 case N32_OP6_LWI:
8324 if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
8325 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
8326 break;
8327 case N32_OP6_SWI:
8328 if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
8329 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
8330 break;
8331 case N32_OP6_HWGP:
8332 if (!IS_WITHIN_U (N32_IMM17S (insn), 7))
8333 break;
8334
8335 if (__GF (insn, 17, 3) == 6)
8336 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM17S (insn));
8337 else if (__GF (insn, 17, 3) == 7)
8338 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM17S (insn));
8339 break;
8340 }
8341
8342 if ((insn16 & 0x8000) == 0)
8343 return 0;
8344
8345 *pinsn16 = insn16;
8346 return 1;
8347 }
8348
8349 /* Convert a 16-bit instruction to 32-bit one.
8350 INSN16 it the input and PINSN it the point to output.
8351 Return non-zero on successful. Otherwise 0 is returned. */
8352
8353 int
8354 nds32_convert_16_to_32 (bfd *abfd, uint16_t insn16, uint32_t *pinsn)
8355 {
8356 uint32_t insn = 0xffffffff;
8357 unsigned long mach = bfd_get_mach (abfd);
8358
8359 /* NOTE: push25, pop25 and movd44 do not have 32-bit variants. */
8360
8361 switch (__GF (insn16, 9, 6))
8362 {
8363 case 0x4: /* add45 */
8364 insn = N32_ALU1 (ADD, N16_RT4 (insn16), N16_RT4 (insn16),
8365 N16_RA5 (insn16));
8366 goto done;
8367 case 0x5: /* sub45 */
8368 insn = N32_ALU1 (SUB, N16_RT4 (insn16), N16_RT4 (insn16),
8369 N16_RA5 (insn16));
8370 goto done;
8371 case 0x6: /* addi45 */
8372 insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
8373 N16_IMM5U (insn16));
8374 goto done;
8375 case 0x7: /* subi45 */
8376 insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
8377 -N16_IMM5U (insn16));
8378 goto done;
8379 case 0x8: /* srai45 */
8380 insn = N32_ALU1 (SRAI, N16_RT4 (insn16), N16_RT4 (insn16),
8381 N16_IMM5U (insn16));
8382 goto done;
8383 case 0x9: /* srli45 */
8384 insn = N32_ALU1 (SRLI, N16_RT4 (insn16), N16_RT4 (insn16),
8385 N16_IMM5U (insn16));
8386 goto done;
8387 case 0xa: /* slli333 */
8388 insn = N32_ALU1 (SLLI, N16_RT3 (insn16), N16_RA3 (insn16),
8389 N16_IMM3U (insn16));
8390 goto done;
8391 case 0xc: /* add333 */
8392 insn = N32_ALU1 (ADD, N16_RT3 (insn16), N16_RA3 (insn16),
8393 N16_RB3 (insn16));
8394 goto done;
8395 case 0xd: /* sub333 */
8396 insn = N32_ALU1 (SUB, N16_RT3 (insn16), N16_RA3 (insn16),
8397 N16_RB3 (insn16));
8398 goto done;
8399 case 0xe: /* addi333 */
8400 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
8401 N16_IMM3U (insn16));
8402 goto done;
8403 case 0xf: /* subi333 */
8404 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
8405 -N16_IMM3U (insn16));
8406 goto done;
8407 case 0x10: /* lwi333 */
8408 insn = N32_TYPE2 (LWI, N16_RT3 (insn16), N16_RA3 (insn16),
8409 N16_IMM3U (insn16));
8410 goto done;
8411 case 0x12: /* lhi333 */
8412 insn = N32_TYPE2 (LHI, N16_RT3 (insn16), N16_RA3 (insn16),
8413 N16_IMM3U (insn16));
8414 goto done;
8415 case 0x13: /* lbi333 */
8416 insn = N32_TYPE2 (LBI, N16_RT3 (insn16), N16_RA3 (insn16),
8417 N16_IMM3U (insn16));
8418 goto done;
8419 case 0x11: /* lwi333.bi */
8420 insn = N32_TYPE2 (LWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
8421 N16_IMM3U (insn16));
8422 goto done;
8423 case 0x14: /* swi333 */
8424 insn = N32_TYPE2 (SWI, N16_RT3 (insn16), N16_RA3 (insn16),
8425 N16_IMM3U (insn16));
8426 goto done;
8427 case 0x16: /* shi333 */
8428 insn = N32_TYPE2 (SHI, N16_RT3 (insn16), N16_RA3 (insn16),
8429 N16_IMM3U (insn16));
8430 goto done;
8431 case 0x17: /* sbi333 */
8432 insn = N32_TYPE2 (SBI, N16_RT3 (insn16), N16_RA3 (insn16),
8433 N16_IMM3U (insn16));
8434 goto done;
8435 case 0x15: /* swi333.bi */
8436 insn = N32_TYPE2 (SWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
8437 N16_IMM3U (insn16));
8438 goto done;
8439 case 0x18: /* addri36.sp */
8440 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), REG_SP,
8441 N16_IMM6U (insn16) << 2);
8442 goto done;
8443 case 0x19: /* lwi45.fe */
8444 insn = N32_TYPE2 (LWI, N16_RT4 (insn16), REG_R8,
8445 (N16_IMM5U (insn16) - 32));
8446 goto done;
8447 case 0x1a: /* lwi450 */
8448 insn = N32_TYPE2 (LWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
8449 goto done;
8450 case 0x1b: /* swi450 */
8451 insn = N32_TYPE2 (SWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
8452 goto done;
8453
8454 /* These are r15 implied instructions. */
8455 case 0x30: /* slts45 */
8456 insn = N32_ALU1 (SLTS, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
8457 goto done;
8458 case 0x31: /* slt45 */
8459 insn = N32_ALU1 (SLT, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
8460 goto done;
8461 case 0x32: /* sltsi45 */
8462 insn = N32_TYPE2 (SLTSI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
8463 goto done;
8464 case 0x33: /* slti45 */
8465 insn = N32_TYPE2 (SLTI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
8466 goto done;
8467 case 0x34: /* beqzs8, bnezs8 */
8468 if (insn16 & N32_BIT (8))
8469 insn = N32_BR2 (BNEZ, REG_TA, N16_IMM8S (insn16));
8470 else
8471 insn = N32_BR2 (BEQZ, REG_TA, N16_IMM8S (insn16));
8472 goto done;
8473
8474 case 0x35: /* break16, ex9.it */
8475 /* Only consider range of v3 break16. */
8476 insn = N32_TYPE0 (MISC, (N16_IMM5U (insn16) << 5) | N32_MISC_BREAK);
8477 goto done;
8478
8479 case 0x3c: /* ifcall9 */
8480 insn = N32_BR2 (SOP0, 0, N16_IMM9U (insn16));
8481 goto done;
8482 case 0x3d: /* movpi45 */
8483 insn = N32_TYPE1 (MOVI, N16_RT4 (insn16), N16_IMM5U (insn16) + 16);
8484 goto done;
8485
8486 case 0x3f: /* MISC33 */
8487 switch (insn16 & 0x7)
8488 {
8489 case 2: /* neg33 */
8490 insn = N32_TYPE2 (SUBRI, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8491 break;
8492 case 3: /* not33 */
8493 insn = N32_ALU1 (NOR, N16_RT3 (insn16), N16_RA3 (insn16),
8494 N16_RA3 (insn16));
8495 break;
8496 case 4: /* mul33 */
8497 insn = N32_ALU2 (MUL, N16_RT3 (insn16), N16_RT3 (insn16),
8498 N16_RA3 (insn16));
8499 break;
8500 case 5: /* xor33 */
8501 insn = N32_ALU1 (XOR, N16_RT3 (insn16), N16_RT3 (insn16),
8502 N16_RA3 (insn16));
8503 break;
8504 case 6: /* and33 */
8505 insn = N32_ALU1 (AND, N16_RT3 (insn16), N16_RT3 (insn16),
8506 N16_RA3 (insn16));
8507 break;
8508 case 7: /* or33 */
8509 insn = N32_ALU1 (OR, N16_RT3 (insn16), N16_RT3 (insn16),
8510 N16_RA3 (insn16));
8511 break;
8512 }
8513 goto done;
8514
8515 case 0xb:
8516 switch (insn16 & 0x7)
8517 {
8518 case 0: /* zeb33 */
8519 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0xff);
8520 break;
8521 case 1: /* zeh33 */
8522 insn = N32_ALU1 (ZEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8523 break;
8524 case 2: /* seb33 */
8525 insn = N32_ALU1 (SEB, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8526 break;
8527 case 3: /* seh33 */
8528 insn = N32_ALU1 (SEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8529 break;
8530 case 4: /* xlsb33 */
8531 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 1);
8532 break;
8533 case 5: /* x11b33 */
8534 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0x7ff);
8535 break;
8536 case 6: /* bmski33 */
8537 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
8538 1 << __GF (insn16, 3, 3));
8539 break;
8540 case 7: /* fexti33 */
8541 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
8542 (1 << (__GF (insn16, 3, 3) + 1)) - 1);
8543 break;
8544 }
8545 goto done;
8546 }
8547
8548 switch (__GF (insn16, 10, 5))
8549 {
8550 case 0x0: /* mov55 or ifret16 */
8551 if (mach >= MACH_V3 && N16_RT5 (insn16) == REG_SP
8552 && N16_RT5 (insn16) == N16_RA5 (insn16))
8553 insn = N32_JREG (JR, 0, 0, 0, 3);
8554 else
8555 insn = N32_TYPE2 (ADDI, N16_RT5 (insn16), N16_RA5 (insn16), 0);
8556 goto done;
8557 case 0x1: /* movi55 */
8558 insn = N32_TYPE1 (MOVI, N16_RT5 (insn16), N16_IMM5S (insn16));
8559 goto done;
8560 case 0x1b: /* addi10s (V2) */
8561 insn = N32_TYPE2 (ADDI, REG_SP, REG_SP, N16_IMM10S (insn16));
8562 goto done;
8563 }
8564
8565 switch (__GF (insn16, 11, 4))
8566 {
8567 case 0x7: /* lwi37.fp/swi37.fp */
8568 if (insn16 & N32_BIT (7)) /* swi37.fp */
8569 insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
8570 else /* lwi37.fp */
8571 insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
8572 goto done;
8573 case 0x8: /* beqz38 */
8574 insn = N32_BR2 (BEQZ, N16_RT38 (insn16), N16_IMM8S (insn16));
8575 goto done;
8576 case 0x9: /* bnez38 */
8577 insn = N32_BR2 (BNEZ, N16_RT38 (insn16), N16_IMM8S (insn16));
8578 goto done;
8579 case 0xa: /* beqs38/j8, implied r5 */
8580 if (N16_RT38 (insn16) == 5)
8581 insn = N32_JI (J, N16_IMM8S (insn16));
8582 else
8583 insn = N32_BR1 (BEQ, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
8584 goto done;
8585 case 0xb: /* bnes38 and others. */
8586 if (N16_RT38 (insn16) == 5)
8587 {
8588 switch (__GF (insn16, 5, 3))
8589 {
8590 case 0: /* jr5 */
8591 insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 0);
8592 break;
8593 case 4: /* ret5 */
8594 insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 1);
8595 break;
8596 case 1: /* jral5 */
8597 insn = N32_JREG (JRAL, REG_LP, N16_RA5 (insn16), 0, 0);
8598 break;
8599 case 2: /* ex9.it imm5 */
8600 /* ex9.it had no 32-bit variantl. */
8601 break;
8602 case 5: /* add5.pc */
8603 /* add5.pc had no 32-bit variantl. */
8604 break;
8605 }
8606 }
8607 else /* bnes38 */
8608 insn = N32_BR1 (BNE, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
8609 goto done;
8610 case 0xe: /* lwi37/swi37 */
8611 if (insn16 & (1 << 7)) /* swi37.sp */
8612 insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
8613 else /* lwi37.sp */
8614 insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
8615 goto done;
8616 }
8617
8618 done:
8619 if (insn & 0x80000000)
8620 return 0;
8621
8622 if (pinsn)
8623 *pinsn = insn;
8624 return 1;
8625 }
8626 \f
8627
8628 static bfd_boolean
8629 is_sda_access_insn (unsigned long insn)
8630 {
8631 switch (N32_OP6 (insn))
8632 {
8633 case N32_OP6_LWI:
8634 case N32_OP6_LHI:
8635 case N32_OP6_LHSI:
8636 case N32_OP6_LBI:
8637 case N32_OP6_LBSI:
8638 case N32_OP6_SWI:
8639 case N32_OP6_SHI:
8640 case N32_OP6_SBI:
8641 case N32_OP6_LWC:
8642 case N32_OP6_LDC:
8643 case N32_OP6_SWC:
8644 case N32_OP6_SDC:
8645 return TRUE;
8646 default:
8647 ;
8648 }
8649 return FALSE;
8650 }
8651
8652 static unsigned long
8653 turn_insn_to_sda_access (uint32_t insn, bfd_signed_vma type, uint32_t *pinsn)
8654 {
8655 uint32_t oinsn = 0;
8656
8657 switch (type)
8658 {
8659 case R_NDS32_GOT_LO12:
8660 case R_NDS32_GOTOFF_LO12:
8661 case R_NDS32_PLTREL_LO12:
8662 case R_NDS32_PLT_GOTREL_LO12:
8663 case R_NDS32_LO12S0_RELA:
8664 switch (N32_OP6 (insn))
8665 {
8666 case N32_OP6_LBI:
8667 /* lbi.gp */
8668 oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
8669 break;
8670 case N32_OP6_LBSI:
8671 /* lbsi.gp */
8672 oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), N32_BIT (19));
8673 break;
8674 case N32_OP6_SBI:
8675 /* sbi.gp */
8676 oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
8677 break;
8678 case N32_OP6_ORI:
8679 /* addi.gp */
8680 oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), N32_BIT (19));
8681 break;
8682 }
8683 break;
8684
8685 case R_NDS32_LO12S1_RELA:
8686 switch (N32_OP6 (insn))
8687 {
8688 case N32_OP6_LHI:
8689 /* lhi.gp */
8690 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
8691 break;
8692 case N32_OP6_LHSI:
8693 /* lhsi.gp */
8694 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (18));
8695 break;
8696 case N32_OP6_SHI:
8697 /* shi.gp */
8698 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (19));
8699 break;
8700 }
8701 break;
8702
8703 case R_NDS32_LO12S2_RELA:
8704 switch (N32_OP6 (insn))
8705 {
8706 case N32_OP6_LWI:
8707 /* lwi.gp */
8708 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
8709 break;
8710 case N32_OP6_SWI:
8711 /* swi.gp */
8712 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
8713 break;
8714 }
8715 break;
8716
8717 case R_NDS32_LO12S2_DP_RELA:
8718 case R_NDS32_LO12S2_SP_RELA:
8719 oinsn = (insn & 0x7ff07000) | (REG_GP << 15);
8720 break;
8721 }
8722
8723 if (oinsn)
8724 *pinsn = oinsn;
8725
8726 return oinsn != 0;
8727 }
8728
8729 /* Linker hasn't found the correct merge section for non-section symbol
8730 in relax time, this work is left to the function elf_link_input_bfd().
8731 So for non-section symbol, _bfd_merged_section_offset is also needed
8732 to find the correct symbol address. */
8733
8734 static bfd_vma
8735 nds32_elf_rela_local_sym (bfd *abfd, Elf_Internal_Sym *sym,
8736 asection **psec, Elf_Internal_Rela *rel)
8737 {
8738 asection *sec = *psec;
8739 bfd_vma relocation;
8740
8741 relocation = (sec->output_section->vma
8742 + sec->output_offset + sym->st_value);
8743 if ((sec->flags & SEC_MERGE) && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
8744 {
8745 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
8746 rel->r_addend =
8747 _bfd_merged_section_offset (abfd, psec,
8748 elf_section_data (sec)->sec_info,
8749 sym->st_value + rel->r_addend);
8750 else
8751 rel->r_addend =
8752 _bfd_merged_section_offset (abfd, psec,
8753 elf_section_data (sec)->sec_info,
8754 sym->st_value) + rel->r_addend;
8755
8756 if (sec != *psec)
8757 {
8758 /* If we have changed the section, and our original section is
8759 marked with SEC_EXCLUDE, it means that the original
8760 SEC_MERGE section has been completely subsumed in some
8761 other SEC_MERGE section. In this case, we need to leave
8762 some info around for --emit-relocs. */
8763 if ((sec->flags & SEC_EXCLUDE) != 0)
8764 sec->kept_section = *psec;
8765 sec = *psec;
8766 }
8767 rel->r_addend -= relocation;
8768 rel->r_addend += sec->output_section->vma + sec->output_offset;
8769 }
8770 return relocation;
8771 }
8772
8773 static bfd_vma
8774 calculate_memory_address (bfd *abfd, Elf_Internal_Rela *irel,
8775 Elf_Internal_Sym *isymbuf,
8776 Elf_Internal_Shdr *symtab_hdr)
8777 {
8778 bfd_signed_vma foff;
8779 bfd_vma symval, addend;
8780 Elf_Internal_Rela irel_fn;
8781 Elf_Internal_Sym *isym;
8782 asection *sym_sec;
8783
8784 /* Get the value of the symbol referred to by the reloc. */
8785 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
8786 {
8787 /* A local symbol. */
8788 isym = isymbuf + ELF32_R_SYM (irel->r_info);
8789
8790 if (isym->st_shndx == SHN_UNDEF)
8791 sym_sec = bfd_und_section_ptr;
8792 else if (isym->st_shndx == SHN_ABS)
8793 sym_sec = bfd_abs_section_ptr;
8794 else if (isym->st_shndx == SHN_COMMON)
8795 sym_sec = bfd_com_section_ptr;
8796 else
8797 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
8798 memcpy (&irel_fn, irel, sizeof (Elf_Internal_Rela));
8799 symval = nds32_elf_rela_local_sym (abfd, isym, &sym_sec, &irel_fn);
8800 addend = irel_fn.r_addend;
8801 }
8802 else
8803 {
8804 unsigned long indx;
8805 struct elf_link_hash_entry *h;
8806
8807 /* An external symbol. */
8808 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
8809 h = elf_sym_hashes (abfd)[indx];
8810 BFD_ASSERT (h != NULL);
8811
8812 while (h->root.type == bfd_link_hash_indirect
8813 || h->root.type == bfd_link_hash_warning)
8814 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8815
8816 if (h->root.type != bfd_link_hash_defined
8817 && h->root.type != bfd_link_hash_defweak)
8818 /* This appears to be a reference to an undefined
8819 symbol. Just ignore it--it will be caught by the
8820 regular reloc processing. */
8821 return 0;
8822
8823 if (h->root.u.def.section->flags & SEC_MERGE)
8824 {
8825 sym_sec = h->root.u.def.section;
8826 symval = _bfd_merged_section_offset (abfd, &sym_sec, elf_section_data
8827 (sym_sec)->sec_info, h->root.u.def.value);
8828 symval = symval + sym_sec->output_section->vma
8829 + sym_sec->output_offset;
8830 }
8831 else
8832 symval = (h->root.u.def.value
8833 + h->root.u.def.section->output_section->vma
8834 + h->root.u.def.section->output_offset);
8835 addend = irel->r_addend;
8836 }
8837
8838 foff = symval + addend;
8839
8840 return foff;
8841 }
8842
8843 static int
8844 is_16bit_NOP (bfd *abfd ATTRIBUTE_UNUSED,
8845 asection *sec, Elf_Internal_Rela *rel)
8846 {
8847 bfd_byte *contents;
8848 unsigned short insn16;
8849
8850 if (!(rel->r_addend & R_NDS32_INSN16_CONVERT_FLAG))
8851 return FALSE;
8852 contents = elf_section_data (sec)->this_hdr.contents;
8853 insn16 = bfd_getb16 (contents + rel->r_offset);
8854 if (insn16 == NDS32_NOP16)
8855 return TRUE;
8856 return FALSE;
8857 }
8858
8859 /* It checks whether the instruction could be converted to
8860 16-bit form and returns the converted one.
8861
8862 `internal_relocs' is supposed to be sorted. */
8863
8864 static int
8865 is_convert_32_to_16 (bfd *abfd, asection *sec,
8866 Elf_Internal_Rela *reloc,
8867 Elf_Internal_Rela *internal_relocs,
8868 Elf_Internal_Rela *irelend,
8869 uint16_t *insn16)
8870 {
8871 #define NORMAL_32_TO_16 (1 << 0)
8872 #define SPECIAL_32_TO_16 (1 << 1)
8873 bfd_byte *contents = NULL;
8874 bfd_signed_vma off;
8875 bfd_vma mem_addr;
8876 uint32_t insn = 0;
8877 Elf_Internal_Rela *pc_rel;
8878 Elf_Internal_Shdr *symtab_hdr;
8879 Elf_Internal_Sym *isymbuf = NULL;
8880 int convert_type;
8881 bfd_vma offset;
8882
8883 if (reloc->r_offset + 4 > sec->size)
8884 return FALSE;
8885
8886 offset = reloc->r_offset;
8887
8888 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
8889 return FALSE;
8890 insn = bfd_getb32 (contents + offset);
8891
8892 if (nds32_convert_32_to_16 (abfd, insn, insn16, NULL))
8893 convert_type = NORMAL_32_TO_16;
8894 else if (special_convert_32_to_16 (insn, insn16, reloc))
8895 convert_type = SPECIAL_32_TO_16;
8896 else
8897 return FALSE;
8898
8899 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8900 if (!nds32_get_local_syms (abfd, sec, &isymbuf))
8901 return FALSE;
8902
8903 /* Find the first relocation of the same relocation-type,
8904 so we iteratie them forward. */
8905 pc_rel = reloc;
8906 while ((pc_rel - 1) >= internal_relocs && pc_rel[-1].r_offset == offset)
8907 pc_rel--;
8908
8909 for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8910 {
8911 if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8912 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8913 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA
8914 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8915 {
8916 off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr);
8917 if (off >= ACCURATE_8BIT_S1 || off < -ACCURATE_8BIT_S1
8918 || off == 0)
8919 return FALSE;
8920 break;
8921 }
8922 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8923 {
8924 /* movi => movi55 */
8925 mem_addr = calculate_memory_address (abfd, pc_rel, isymbuf,
8926 symtab_hdr);
8927 /* mem_addr is unsigned, but the value should
8928 be between [-16, 15]. */
8929 if ((mem_addr + 0x10) >> 5)
8930 return FALSE;
8931 break;
8932 }
8933 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_20)
8934 || (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_LO12))
8935 {
8936 /* It never happen movi to movi55 for R_NDS32_TLS_LE_20,
8937 because it can be relaxed to addi for TLS_LE_ADD. */
8938 return FALSE;
8939 }
8940 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8941 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8942 && (reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG)
8943 && convert_type == SPECIAL_32_TO_16)
8944 {
8945 /* fp-as-gp
8946 We've selected a best fp-base for this access, so we can
8947 always resolve it anyway. Do nothing. */
8948 break;
8949 }
8950 else if ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_NONE
8951 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_RELA_GNU_VTINHERIT))
8952 || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_RELA_GNU_VTENTRY)
8953 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_INSN16))
8954 || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_LOADSTORE)
8955 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_DWARF2_OP1_RELA)))
8956 {
8957 /* Prevent unresolved addi instruction translate
8958 to addi45 or addi333. */
8959 return FALSE;
8960 }
8961 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8962 {
8963 off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr);
8964 if (off >= ACCURATE_U9BIT_S1 || off <= 0)
8965 return FALSE;
8966 break;
8967 }
8968 }
8969
8970 return TRUE;
8971 }
8972
8973 static void
8974 nds32_elf_write_16 (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *contents,
8975 Elf_Internal_Rela *reloc,
8976 Elf_Internal_Rela *internal_relocs,
8977 Elf_Internal_Rela *irelend,
8978 unsigned short insn16)
8979 {
8980 Elf_Internal_Rela *pc_rel;
8981 bfd_vma offset;
8982
8983 offset = reloc->r_offset;
8984 bfd_putb16 (insn16, contents + offset);
8985 /* Find the first relocation of the same relocation-type,
8986 so we iteratie them forward. */
8987 pc_rel = reloc;
8988 while ((pc_rel - 1) > internal_relocs && pc_rel[-1].r_offset == offset)
8989 pc_rel--;
8990
8991 for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8992 {
8993 if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8994 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8995 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA)
8996 {
8997 pc_rel->r_info =
8998 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PCREL_RELA);
8999 }
9000 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
9001 pc_rel->r_info =
9002 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PLTREL);
9003 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
9004 pc_rel->r_info =
9005 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_5_RELA);
9006 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
9007 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
9008 pc_rel->r_info =
9009 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_SDA_FP7U2_RELA);
9010 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
9011 pc_rel->r_info =
9012 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_10IFCU_PCREL_RELA);
9013 }
9014 }
9015
9016 /* Find a relocation of type specified by `reloc_type'
9017 of the same r_offset with reloc.
9018 If not found, return irelend.
9019
9020 Assuming relocations are sorted by r_offset,
9021 we find the relocation from `reloc' backward untill relocs,
9022 or find it from `reloc' forward untill irelend. */
9023
9024 static Elf_Internal_Rela *
9025 find_relocs_at_address (Elf_Internal_Rela *reloc,
9026 Elf_Internal_Rela *relocs,
9027 Elf_Internal_Rela *irelend,
9028 enum elf_nds32_reloc_type reloc_type)
9029 {
9030 Elf_Internal_Rela *rel_t;
9031
9032 /* Find backward. */
9033 for (rel_t = reloc;
9034 rel_t >= relocs && rel_t->r_offset == reloc->r_offset;
9035 rel_t--)
9036 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
9037 return rel_t;
9038
9039 /* We didn't find it backward. Try find it forward. */
9040 for (rel_t = reloc;
9041 rel_t < irelend && rel_t->r_offset == reloc->r_offset;
9042 rel_t++)
9043 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
9044 return rel_t;
9045
9046 return irelend;
9047 }
9048
9049 /* Find a relocation of specified type and offset.
9050 `reloc' is just a refence point to find a relocation at specified offset.
9051 If not found, return irelend.
9052
9053 Assuming relocations are sorted by r_offset,
9054 we find the relocation from `reloc' backward untill relocs,
9055 or find it from `reloc' forward untill irelend. */
9056
9057 static Elf_Internal_Rela *
9058 find_relocs_at_address_addr (Elf_Internal_Rela *reloc,
9059 Elf_Internal_Rela *relocs,
9060 Elf_Internal_Rela *irelend,
9061 enum elf_nds32_reloc_type reloc_type,
9062 bfd_vma offset_p)
9063 {
9064 Elf_Internal_Rela *rel_t = NULL;
9065
9066 /* First, we try to find a relocation of offset `offset_p',
9067 and then we use find_relocs_at_address to find specific type. */
9068
9069 if (reloc->r_offset > offset_p)
9070 {
9071 /* Find backward. */
9072 for (rel_t = reloc;
9073 rel_t >= relocs && rel_t->r_offset > offset_p; rel_t--)
9074 /* Do nothing. */;
9075 }
9076 else if (reloc->r_offset < offset_p)
9077 {
9078 /* Find forward. */
9079 for (rel_t = reloc;
9080 rel_t < irelend && rel_t->r_offset < offset_p; rel_t++)
9081 /* Do nothing. */;
9082 }
9083 else
9084 rel_t = reloc;
9085
9086 /* Not found? */
9087 if (rel_t < relocs || rel_t == irelend || rel_t->r_offset != offset_p)
9088 return irelend;
9089
9090 return find_relocs_at_address (rel_t, relocs, irelend, reloc_type);
9091 }
9092
9093 typedef struct nds32_elf_blank nds32_elf_blank_t;
9094 struct nds32_elf_blank
9095 {
9096 /* Where the blank begins. */
9097 bfd_vma offset;
9098 /* The size of the blank. */
9099 bfd_vma size;
9100 /* The accumulative size before this blank. */
9101 bfd_vma total_size;
9102 nds32_elf_blank_t *next;
9103 nds32_elf_blank_t *prev;
9104 };
9105
9106 static nds32_elf_blank_t *blank_free_list = NULL;
9107
9108 static nds32_elf_blank_t *
9109 create_nds32_elf_blank (bfd_vma offset_p, bfd_vma size_p)
9110 {
9111 nds32_elf_blank_t *blank_t;
9112
9113 if (blank_free_list)
9114 {
9115 blank_t = blank_free_list;
9116 blank_free_list = blank_free_list->next;
9117 }
9118 else
9119 blank_t = bfd_malloc (sizeof (nds32_elf_blank_t));
9120
9121 if (blank_t == NULL)
9122 return NULL;
9123
9124 blank_t->offset = offset_p;
9125 blank_t->size = size_p;
9126 blank_t->total_size = 0;
9127 blank_t->next = NULL;
9128 blank_t->prev = NULL;
9129
9130 return blank_t;
9131 }
9132
9133 static void
9134 remove_nds32_elf_blank (nds32_elf_blank_t *blank_p)
9135 {
9136 if (blank_free_list)
9137 {
9138 blank_free_list->prev = blank_p;
9139 blank_p->next = blank_free_list;
9140 }
9141 else
9142 blank_p->next = NULL;
9143
9144 blank_p->prev = NULL;
9145 blank_free_list = blank_p;
9146 }
9147
9148 static void
9149 clean_nds32_elf_blank (void)
9150 {
9151 nds32_elf_blank_t *blank_t;
9152
9153 while (blank_free_list)
9154 {
9155 blank_t = blank_free_list;
9156 blank_free_list = blank_free_list->next;
9157 free (blank_t);
9158 }
9159 }
9160
9161 static nds32_elf_blank_t *
9162 search_nds32_elf_blank (nds32_elf_blank_t *blank_p, bfd_vma addr)
9163 {
9164 nds32_elf_blank_t *blank_t;
9165
9166 if (!blank_p)
9167 return NULL;
9168 blank_t = blank_p;
9169
9170 while (blank_t && addr < blank_t->offset)
9171 blank_t = blank_t->prev;
9172 while (blank_t && blank_t->next && addr >= blank_t->next->offset)
9173 blank_t = blank_t->next;
9174
9175 return blank_t;
9176 }
9177
9178 static bfd_vma
9179 get_nds32_elf_blank_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
9180 int overwrite)
9181 {
9182 nds32_elf_blank_t *blank_t;
9183
9184 blank_t = search_nds32_elf_blank (*blank_p, addr);
9185 if (!blank_t)
9186 return 0;
9187
9188 if (overwrite)
9189 *blank_p = blank_t;
9190
9191 if (addr < blank_t->offset + blank_t->size)
9192 return blank_t->total_size + (addr - blank_t->offset);
9193 else
9194 return blank_t->total_size + blank_t->size;
9195 }
9196
9197 static bfd_boolean
9198 insert_nds32_elf_blank (nds32_elf_blank_t **blank_p, bfd_vma addr, bfd_vma len)
9199 {
9200 nds32_elf_blank_t *blank_t, *blank_t2;
9201
9202 if (!*blank_p)
9203 {
9204 *blank_p = create_nds32_elf_blank (addr, len);
9205 return *blank_p ? TRUE : FALSE;
9206 }
9207
9208 blank_t = search_nds32_elf_blank (*blank_p, addr);
9209
9210 if (blank_t == NULL)
9211 {
9212 blank_t = create_nds32_elf_blank (addr, len);
9213 if (!blank_t)
9214 return FALSE;
9215 while ((*blank_p)->prev != NULL)
9216 *blank_p = (*blank_p)->prev;
9217 blank_t->next = *blank_p;
9218 (*blank_p)->prev = blank_t;
9219 (*blank_p) = blank_t;
9220 return TRUE;
9221 }
9222
9223 if (addr < blank_t->offset + blank_t->size)
9224 {
9225 /* Extend the origin blank. */
9226 if (addr + len > blank_t->offset + blank_t->size)
9227 blank_t->size = addr + len - blank_t->offset;
9228 }
9229 else
9230 {
9231 blank_t2 = create_nds32_elf_blank (addr, len);
9232 if (!blank_t2)
9233 return FALSE;
9234 if (blank_t->next)
9235 {
9236 blank_t->next->prev = blank_t2;
9237 blank_t2->next = blank_t->next;
9238 }
9239 blank_t2->prev = blank_t;
9240 blank_t->next = blank_t2;
9241 *blank_p = blank_t2;
9242 }
9243
9244 return TRUE;
9245 }
9246
9247 static bfd_boolean
9248 insert_nds32_elf_blank_recalc_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
9249 bfd_vma len)
9250 {
9251 nds32_elf_blank_t *blank_t;
9252
9253 if (!insert_nds32_elf_blank (blank_p, addr, len))
9254 return FALSE;
9255
9256 blank_t = *blank_p;
9257
9258 if (!blank_t->prev)
9259 {
9260 blank_t->total_size = 0;
9261 blank_t = blank_t->next;
9262 }
9263
9264 while (blank_t)
9265 {
9266 blank_t->total_size = blank_t->prev->total_size + blank_t->prev->size;
9267 blank_t = blank_t->next;
9268 }
9269
9270 return TRUE;
9271 }
9272
9273 static void
9274 calc_nds32_blank_total (nds32_elf_blank_t *blank_p)
9275 {
9276 nds32_elf_blank_t *blank_t;
9277 bfd_vma total_size = 0;
9278
9279 if (!blank_p)
9280 return;
9281
9282 blank_t = blank_p;
9283 while (blank_t->prev)
9284 blank_t = blank_t->prev;
9285 while (blank_t)
9286 {
9287 blank_t->total_size = total_size;
9288 total_size += blank_t->size;
9289 blank_t = blank_t->next;
9290 }
9291 }
9292
9293 static bfd_boolean
9294 nds32_elf_relax_delete_blanks (bfd *abfd, asection *sec,
9295 nds32_elf_blank_t *blank_p)
9296 {
9297 Elf_Internal_Shdr *symtab_hdr; /* Symbol table header of this bfd. */
9298 Elf_Internal_Sym *isym = NULL; /* Symbol table of this bfd. */
9299 Elf_Internal_Sym *isymend; /* Symbol entry iterator. */
9300 unsigned int sec_shndx; /* The section the be relaxed. */
9301 bfd_byte *contents; /* Contents data of iterating section. */
9302 Elf_Internal_Rela *internal_relocs;
9303 Elf_Internal_Rela *irel;
9304 Elf_Internal_Rela *irelend;
9305 struct elf_link_hash_entry **sym_hashes;
9306 struct elf_link_hash_entry **end_hashes;
9307 unsigned int symcount;
9308 asection *sect;
9309 nds32_elf_blank_t *blank_t;
9310 nds32_elf_blank_t *blank_t2;
9311 nds32_elf_blank_t *blank_head;
9312
9313 blank_head = blank_t = blank_p;
9314 while (blank_head->prev != NULL)
9315 blank_head = blank_head->prev;
9316 while (blank_t->next != NULL)
9317 blank_t = blank_t->next;
9318
9319 if (blank_t->offset + blank_t->size <= sec->size)
9320 {
9321 blank_t->next = create_nds32_elf_blank (sec->size + 4, 0);
9322 blank_t->next->prev = blank_t;
9323 }
9324 if (blank_head->offset > 0)
9325 {
9326 blank_head->prev = create_nds32_elf_blank (0, 0);
9327 blank_head->prev->next = blank_head;
9328 blank_head = blank_head->prev;
9329 }
9330
9331 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
9332
9333 /* The deletion must stop at the next ALIGN reloc for an alignment
9334 power larger than the number of bytes we are deleting. */
9335
9336 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9337 if (!nds32_get_local_syms (abfd, sec, &isym))
9338 return FALSE;
9339
9340 if (isym == NULL)
9341 {
9342 isym = bfd_elf_get_elf_syms (abfd, symtab_hdr,
9343 symtab_hdr->sh_info, 0, NULL, NULL, NULL);
9344 symtab_hdr->contents = (bfd_byte *) isym;
9345 }
9346
9347 if (isym == NULL || symtab_hdr->sh_info == 0)
9348 return FALSE;
9349
9350 blank_t = blank_head;
9351 calc_nds32_blank_total (blank_head);
9352
9353 for (sect = abfd->sections; sect != NULL; sect = sect->next)
9354 {
9355 /* Adjust all the relocs. */
9356
9357 /* Relocations MUST be kept in memory, because relaxation adjust them. */
9358 internal_relocs = _bfd_elf_link_read_relocs (abfd, sect, NULL, NULL,
9359 TRUE /* keep_memory */);
9360 irelend = internal_relocs + sect->reloc_count;
9361
9362 blank_t = blank_head;
9363 blank_t2 = blank_head;
9364
9365 if (!(sect->flags & SEC_RELOC))
9366 continue;
9367
9368 nds32_get_section_contents (abfd, sect, &contents, TRUE);
9369
9370 for (irel = internal_relocs; irel < irelend; irel++)
9371 {
9372 bfd_vma raddr;
9373
9374 if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_DIFF8
9375 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_DIFF32
9376 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
9377 {
9378 unsigned long val = 0;
9379 unsigned long mask;
9380 long before, between;
9381 long offset = 0;
9382
9383 switch (ELF32_R_TYPE (irel->r_info))
9384 {
9385 case R_NDS32_DIFF8:
9386 offset = bfd_get_8 (abfd, contents + irel->r_offset);
9387 break;
9388 case R_NDS32_DIFF16:
9389 offset = bfd_get_16 (abfd, contents + irel->r_offset);
9390 break;
9391 case R_NDS32_DIFF32:
9392 val = bfd_get_32 (abfd, contents + irel->r_offset);
9393 /* Get the signed bit and mask for the high part. The
9394 gcc will alarm when right shift 32-bit since the
9395 type size of long may be 32-bit. */
9396 mask = 0 - (val >> 31);
9397 if (mask)
9398 offset = (val | (mask - 0xffffffff));
9399 else
9400 offset = val;
9401 break;
9402 default:
9403 BFD_ASSERT (0);
9404 }
9405
9406 /* DIFF value
9407 0 |encoded in location|
9408 |------------|-------------------|---------
9409 sym+off(addend)
9410 -- before ---| *****************
9411 --------------------- between ---|
9412
9413 We only care how much data are relax between DIFF,
9414 marked as ***. */
9415
9416 before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
9417 between = get_nds32_elf_blank_total (&blank_t,
9418 irel->r_addend + offset, 0);
9419 if (between == before)
9420 goto done_adjust_diff;
9421
9422 switch (ELF32_R_TYPE (irel->r_info))
9423 {
9424 case R_NDS32_DIFF8:
9425 bfd_put_8 (abfd, offset - (between - before),
9426 contents + irel->r_offset);
9427 break;
9428 case R_NDS32_DIFF16:
9429 bfd_put_16 (abfd, offset - (between - before),
9430 contents + irel->r_offset);
9431 break;
9432 case R_NDS32_DIFF32:
9433 bfd_put_32 (abfd, offset - (between - before),
9434 contents + irel->r_offset);
9435 break;
9436 }
9437 }
9438 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_DIFF_ULEB128
9439 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
9440 {
9441 bfd_vma val = 0;
9442 unsigned int len = 0;
9443 unsigned long before, between;
9444 bfd_byte *endp, *p;
9445
9446 val = _bfd_read_unsigned_leb128 (abfd, contents + irel->r_offset,
9447 &len);
9448
9449 before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
9450 between = get_nds32_elf_blank_total (&blank_t,
9451 irel->r_addend + val, 0);
9452 if (between == before)
9453 goto done_adjust_diff;
9454
9455 p = contents + irel->r_offset;
9456 endp = p + len -1;
9457 memset (p, 0x80, len);
9458 *(endp) = 0;
9459 p = write_uleb128 (p, val - (between - before)) - 1;
9460 if (p < endp)
9461 *p |= 0x80;
9462 }
9463 done_adjust_diff:
9464
9465 if (sec == sect)
9466 {
9467 raddr = irel->r_offset;
9468 irel->r_offset -= get_nds32_elf_blank_total (&blank_t2,
9469 irel->r_offset, 1);
9470
9471 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
9472 continue;
9473 if (blank_t2 && blank_t2->next
9474 && (blank_t2->offset > raddr
9475 || blank_t2->next->offset <= raddr))
9476 _bfd_error_handler
9477 (_("%pB: error: search_nds32_elf_blank reports wrong node"),
9478 abfd);
9479
9480 /* Mark reloc in deleted portion as NONE.
9481 For some relocs like R_NDS32_LABEL that doesn't modify the
9482 content in the section. R_NDS32_LABEL doesn't belong to the
9483 instruction in the section, so we should preserve it. */
9484 if (raddr >= blank_t2->offset
9485 && raddr < blank_t2->offset + blank_t2->size
9486 && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL
9487 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_BEGIN
9488 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
9489 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
9490 && ELF32_R_TYPE (irel->r_info) != R_NDS32_SUBTRAHEND
9491 && ELF32_R_TYPE (irel->r_info) != R_NDS32_MINUEND)
9492 {
9493 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
9494 R_NDS32_NONE);
9495 continue;
9496 }
9497 }
9498
9499 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE
9500 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
9501 || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
9502 continue;
9503
9504 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info
9505 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx
9506 && ELF_ST_TYPE (isym[ELF32_R_SYM (irel->r_info)].st_info) == STT_SECTION)
9507 {
9508 if (irel->r_addend <= sec->size)
9509 irel->r_addend -=
9510 get_nds32_elf_blank_total (&blank_t, irel->r_addend, 1);
9511 }
9512 }
9513 }
9514
9515 /* Adjust the local symbols defined in this section. */
9516 blank_t = blank_head;
9517 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
9518 {
9519 if (isym->st_shndx == sec_shndx)
9520 {
9521 if (isym->st_value <= sec->size)
9522 {
9523 bfd_vma ahead;
9524 bfd_vma orig_addr = isym->st_value;
9525
9526 ahead = get_nds32_elf_blank_total (&blank_t, isym->st_value, 1);
9527 isym->st_value -= ahead;
9528
9529 /* Adjust function size. */
9530 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC
9531 && isym->st_size > 0)
9532 isym->st_size -=
9533 get_nds32_elf_blank_total
9534 (&blank_t, orig_addr + isym->st_size, 0) - ahead;
9535 }
9536 }
9537 }
9538
9539 /* Now adjust the global symbols defined in this section. */
9540 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
9541 - symtab_hdr->sh_info);
9542 sym_hashes = elf_sym_hashes (abfd);
9543 end_hashes = sym_hashes + symcount;
9544 blank_t = blank_head;
9545 for (; sym_hashes < end_hashes; sym_hashes++)
9546 {
9547 struct elf_link_hash_entry *sym_hash = *sym_hashes;
9548
9549 if ((sym_hash->root.type == bfd_link_hash_defined
9550 || sym_hash->root.type == bfd_link_hash_defweak)
9551 && sym_hash->root.u.def.section == sec)
9552 {
9553 if (sym_hash->root.u.def.value <= sec->size)
9554 {
9555 bfd_vma ahead;
9556 bfd_vma orig_addr = sym_hash->root.u.def.value;
9557
9558 ahead = get_nds32_elf_blank_total (&blank_t, sym_hash->root.u.def.value, 1);
9559 sym_hash->root.u.def.value -= ahead;
9560
9561 /* Adjust function size. */
9562 if (sym_hash->type == STT_FUNC)
9563 sym_hash->size -=
9564 get_nds32_elf_blank_total
9565 (&blank_t, orig_addr + sym_hash->size, 0) - ahead;
9566
9567 }
9568 }
9569 }
9570
9571 contents = elf_section_data (sec)->this_hdr.contents;
9572 blank_t = blank_head;
9573 while (blank_t->next)
9574 {
9575 /* Actually delete the bytes. */
9576
9577 /* If current blank is the last blank overlap with current section,
9578 go to finish process. */
9579 if (sec->size <= (blank_t->next->offset))
9580 break;
9581
9582 memmove (contents + blank_t->offset - blank_t->total_size,
9583 contents + blank_t->offset + blank_t->size,
9584 blank_t->next->offset - (blank_t->offset + blank_t->size));
9585
9586 blank_t = blank_t->next;
9587 }
9588
9589 if (sec->size > (blank_t->offset + blank_t->size))
9590 {
9591 /* There are remaining code between blank and section boundary.
9592 Move the remaining code to appropriate location. */
9593 memmove (contents + blank_t->offset - blank_t->total_size,
9594 contents + blank_t->offset + blank_t->size,
9595 sec->size - (blank_t->offset + blank_t->size));
9596 sec->size -= blank_t->total_size + blank_t->size;
9597 }
9598 else
9599 /* This blank is not entirely included in the section,
9600 reduce the section size by only part of the blank size. */
9601 sec->size -= blank_t->total_size + (sec->size - blank_t->offset);
9602
9603 while (blank_head)
9604 {
9605 blank_t = blank_head;
9606 blank_head = blank_head->next;
9607 remove_nds32_elf_blank (blank_t);
9608 }
9609
9610 return TRUE;
9611 }
9612
9613 /* Get the contents of a section. */
9614
9615 static int
9616 nds32_get_section_contents (bfd *abfd, asection *sec,
9617 bfd_byte **contents_p, bfd_boolean cache)
9618 {
9619 /* Get the section contents. */
9620 if (elf_section_data (sec)->this_hdr.contents != NULL)
9621 *contents_p = elf_section_data (sec)->this_hdr.contents;
9622 else
9623 {
9624 if (!bfd_malloc_and_get_section (abfd, sec, contents_p))
9625 return FALSE;
9626 if (cache)
9627 elf_section_data (sec)->this_hdr.contents = *contents_p;
9628 }
9629
9630 return TRUE;
9631 }
9632
9633 /* Get the contents of the internal symbol of abfd. */
9634
9635 static int
9636 nds32_get_local_syms (bfd *abfd, asection *sec ATTRIBUTE_UNUSED,
9637 Elf_Internal_Sym **isymbuf_p)
9638 {
9639 Elf_Internal_Shdr *symtab_hdr;
9640 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9641
9642 /* Read this BFD's local symbols if we haven't done so already. */
9643 if (*isymbuf_p == NULL && symtab_hdr->sh_info != 0)
9644 {
9645 *isymbuf_p = (Elf_Internal_Sym *) symtab_hdr->contents;
9646 if (*isymbuf_p == NULL)
9647 {
9648 *isymbuf_p = bfd_elf_get_elf_syms (abfd, symtab_hdr,
9649 symtab_hdr->sh_info, 0,
9650 NULL, NULL, NULL);
9651 if (*isymbuf_p == NULL)
9652 return FALSE;
9653 }
9654 }
9655 symtab_hdr->contents = (bfd_byte *) (*isymbuf_p);
9656
9657 return TRUE;
9658 }
9659
9660 /* Range of small data. */
9661 static bfd_vma sdata_range[2][2];
9662 static bfd_vma const sdata_init_range[2] =
9663 { ACCURATE_12BIT_S1, ACCURATE_19BIT };
9664
9665 static int
9666 nds32_elf_insn_size (bfd *abfd ATTRIBUTE_UNUSED,
9667 bfd_byte *contents, bfd_vma addr)
9668 {
9669 unsigned long insn = bfd_getb32 (contents + addr);
9670
9671 if (insn & 0x80000000)
9672 return 2;
9673
9674 return 4;
9675 }
9676
9677 /* Set the gp relax range. We have to measure the safe range
9678 to do gp relaxation. */
9679
9680 static void
9681 relax_range_measurement (bfd *abfd)
9682 {
9683 asection *sec_f, *sec_b;
9684 /* For upper bound. */
9685 bfd_vma maxpgsz = get_elf_backend_data (abfd)->maxpagesize;
9686 bfd_vma align;
9687 static int decide_relax_range = 0;
9688 int i;
9689 int range_number = ARRAY_SIZE (sdata_init_range);
9690
9691 if (decide_relax_range)
9692 return;
9693 decide_relax_range = 1;
9694
9695 if (sda_rela_sec == NULL)
9696 {
9697 /* Since there is no data sections, we assume the range is page size. */
9698 for (i = 0; i < range_number; i++)
9699 {
9700 sdata_range[i][0] = sdata_init_range[i] - 0x1000;
9701 sdata_range[i][1] = sdata_init_range[i] - 0x1000;
9702 }
9703 return;
9704 }
9705
9706 /* Get the biggest alignment power after the gp located section. */
9707 sec_f = sda_rela_sec->output_section;
9708 sec_b = sec_f->next;
9709 align = 0;
9710 while (sec_b != NULL)
9711 {
9712 if ((unsigned)(1 << sec_b->alignment_power) > align)
9713 align = (1 << sec_b->alignment_power);
9714 sec_b = sec_b->next;
9715 }
9716
9717 /* I guess we can not determine the section before
9718 gp located section, so we assume the align is max page size. */
9719 for (i = 0; i < range_number; i++)
9720 {
9721 sdata_range[i][1] = sdata_init_range[i] - align;
9722 BFD_ASSERT (sdata_range[i][1] <= sdata_init_range[i]);
9723 sdata_range[i][0] = sdata_init_range[i] - maxpgsz;
9724 BFD_ASSERT (sdata_range[i][0] <= sdata_init_range[i]);
9725 }
9726 }
9727
9728 /* These are macros used to check flags encoded in r_addend.
9729 They are only used by nds32_elf_relax_section (). */
9730 #define GET_SEQ_LEN(addend) ((addend) & 0x000000ff)
9731 #define IS_1ST_CONVERT(addend) ((addend) & 0x80000000)
9732 #define IS_OPTIMIZE(addend) ((addend) & 0x40000000)
9733 #define IS_16BIT_ON(addend) ((addend) & 0x20000000)
9734
9735 static const char * unrecognized_reloc_msg =
9736 /* xgettext:c-format */
9737 N_("%pB: warning: %s points to unrecognized reloc at %#" PRIx64);
9738
9739 /* Relax LONGCALL1 relocation for nds32_elf_relax_section. */
9740
9741 static bfd_boolean
9742 nds32_elf_relax_longcall1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9743 Elf_Internal_Rela *internal_relocs, int *insn_len,
9744 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9745 Elf_Internal_Shdr *symtab_hdr)
9746 {
9747 /* There are 3 variations for LONGCALL1
9748 case 4-4-2; 16-bit on, optimize off or optimize for space
9749 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9750 ori ta, ta, lo12(symbol) ; LO12S0
9751 jral5 ta ;
9752
9753 case 4-4-4; 16-bit off, optimize don't care
9754 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9755 ori ta, ta, lo12(symbol) ; LO12S0
9756 jral ta ;
9757
9758 case 4-4-4; 16-bit on, optimize for speed
9759 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9760 ori ta, ta, lo12(symbol) ; LO12S0
9761 jral ta ;
9762 Check code for -mlong-calls output. */
9763
9764 /* Get the reloc for the address from which the register is
9765 being loaded. This reloc will tell us which function is
9766 actually being called. */
9767
9768 bfd_vma laddr;
9769 int seq_len; /* Original length of instruction sequence. */
9770 uint32_t insn;
9771 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9772 bfd_signed_vma foff;
9773 uint16_t insn16;
9774
9775 irelend = internal_relocs + sec->reloc_count;
9776 seq_len = GET_SEQ_LEN (irel->r_addend);
9777 laddr = irel->r_offset;
9778 *insn_len = seq_len;
9779
9780 hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9781 R_NDS32_HI20_RELA, laddr);
9782 lo_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9783 R_NDS32_LO12S0_ORI_RELA,
9784 laddr + 4);
9785
9786 if (hi_irelfn == irelend || lo_irelfn == irelend)
9787 {
9788 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL1",
9789 (uint64_t) irel->r_offset);
9790 return FALSE;
9791 }
9792
9793 /* Get the value of the symbol referred to by the reloc. */
9794 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
9795
9796 /* This condition only happened when symbol is undefined. */
9797 if (foff == 0
9798 || foff < -CONSERVATIVE_24BIT_S1
9799 || foff >= CONSERVATIVE_24BIT_S1)
9800 return FALSE;
9801
9802 /* Relax to: jal symbol; 25_PCREL. */
9803 /* For simplicity of coding, we are going to modify the section
9804 contents, the section relocs, and the BFD symbol table. We
9805 must tell the rest of the code not to free up this
9806 information. It would be possible to instead create a table
9807 of changes which have to be made, as is done in coff-mips.c;
9808 that would be more work, but would require less memory when
9809 the linker is run. */
9810
9811 /* Replace the long call with a jal. */
9812 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9813 R_NDS32_25_PCREL_RELA);
9814 irel->r_addend = hi_irelfn->r_addend;
9815
9816 /* We don't resolve this here but resolve it in relocate_section. */
9817 insn = INSN_JAL;
9818 bfd_putb32 (insn, contents + irel->r_offset);
9819
9820 hi_irelfn->r_info =
9821 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9822 lo_irelfn->r_info =
9823 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9824 *insn_len = 4;
9825
9826 if (seq_len & 0x2)
9827 {
9828 insn16 = NDS32_NOP16;
9829 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9830 lo_irelfn->r_info =
9831 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9832 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9833 *insn_len += 2;
9834 }
9835 return TRUE;
9836 }
9837
9838 #define CONVERT_CONDITION_CALL(insn) (((insn) & 0xffff0000) ^ 0x90000)
9839 /* Relax LONGCALL2 relocation for nds32_elf_relax_section. */
9840
9841 static bfd_boolean
9842 nds32_elf_relax_longcall2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9843 Elf_Internal_Rela *internal_relocs, int *insn_len,
9844 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9845 Elf_Internal_Shdr *symtab_hdr)
9846 {
9847 /* bltz rt, .L1 ; LONGCALL2
9848 jal symbol ; 25_PCREL
9849 .L1: */
9850
9851 /* Get the reloc for the address from which the register is
9852 being loaded. This reloc will tell us which function is
9853 actually being called. */
9854
9855 bfd_vma laddr;
9856 uint32_t insn;
9857 Elf_Internal_Rela *i1_irelfn, *cond_irelfn, *irelend;
9858 bfd_signed_vma foff;
9859
9860 irelend = internal_relocs + sec->reloc_count;
9861 laddr = irel->r_offset;
9862 i1_irelfn =
9863 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9864 R_NDS32_25_PCREL_RELA, laddr + 4);
9865
9866 if (i1_irelfn == irelend)
9867 {
9868 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL2",
9869 (uint64_t) irel->r_offset);
9870 return FALSE;
9871 }
9872
9873 insn = bfd_getb32 (contents + laddr);
9874
9875 /* Get the value of the symbol referred to by the reloc. */
9876 foff = calculate_offset (abfd, sec, i1_irelfn, isymbuf, symtab_hdr);
9877
9878 if (foff == 0
9879 || foff < -CONSERVATIVE_16BIT_S1
9880 || foff >= CONSERVATIVE_16BIT_S1)
9881 return FALSE;
9882
9883 /* Relax to bgezal rt, label ; 17_PCREL
9884 or bltzal rt, label ; 17_PCREL */
9885
9886 /* Convert to complimentary conditional call. */
9887 insn = CONVERT_CONDITION_CALL (insn);
9888
9889 /* For simplicity of coding, we are going to modify the section
9890 contents, the section relocs, and the BFD symbol table. We
9891 must tell the rest of the code not to free up this
9892 information. It would be possible to instead create a table
9893 of changes which have to be made, as is done in coff-mips.c;
9894 that would be more work, but would require less memory when
9895 the linker is run. */
9896
9897 /* Clean unnessary relocations. */
9898 i1_irelfn->r_info =
9899 ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info), R_NDS32_NONE);
9900 cond_irelfn =
9901 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9902 R_NDS32_17_PCREL_RELA, laddr);
9903 if (cond_irelfn != irelend)
9904 cond_irelfn->r_info =
9905 ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info), R_NDS32_NONE);
9906
9907 /* Replace the long call with a bgezal. */
9908 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info),
9909 R_NDS32_17_PCREL_RELA);
9910 irel->r_addend = i1_irelfn->r_addend;
9911
9912 bfd_putb32 (insn, contents + irel->r_offset);
9913
9914 *insn_len = 4;
9915 return TRUE;
9916 }
9917
9918 /* Relax LONGCALL3 relocation for nds32_elf_relax_section. */
9919
9920 static bfd_boolean
9921 nds32_elf_relax_longcall3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9922 Elf_Internal_Rela *internal_relocs, int *insn_len,
9923 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9924 Elf_Internal_Shdr *symtab_hdr)
9925 {
9926 /* There are 3 variations for LONGCALL3
9927 case 4-4-4-2; 16-bit on, optimize off or optimize for space
9928 bltz rt, $1 ; LONGCALL3
9929 sethi ta, hi20(symbol) ; HI20
9930 ori ta, ta, lo12(symbol) ; LO12S0
9931 jral5 ta ;
9932 $1
9933
9934 case 4-4-4-4; 16-bit off, optimize don't care
9935 bltz rt, $1 ; LONGCALL3
9936 sethi ta, hi20(symbol) ; HI20
9937 ori ta, ta, lo12(symbol) ; LO12S0
9938 jral ta ;
9939 $1
9940
9941 case 4-4-4-4; 16-bit on, optimize for speed
9942 bltz rt, $1 ; LONGCALL3
9943 sethi ta, hi20(symbol) ; HI20
9944 ori ta, ta, lo12(symbol) ; LO12S0
9945 jral ta ;
9946 $1 */
9947
9948 /* Get the reloc for the address from which the register is
9949 being loaded. This reloc will tell us which function is
9950 actually being called. */
9951
9952 bfd_vma laddr;
9953 int seq_len; /* Original length of instruction sequence. */
9954 uint32_t insn;
9955 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9956 bfd_signed_vma foff;
9957 uint16_t insn16;
9958
9959 irelend = internal_relocs + sec->reloc_count;
9960 seq_len = GET_SEQ_LEN (irel->r_addend);
9961 laddr = irel->r_offset;
9962 *insn_len = seq_len;
9963
9964 hi_irelfn =
9965 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9966 R_NDS32_HI20_RELA, laddr + 4);
9967 lo_irelfn =
9968 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9969 R_NDS32_LO12S0_ORI_RELA, laddr + 8);
9970
9971 if (hi_irelfn == irelend || lo_irelfn == irelend)
9972 {
9973 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL3",
9974 (uint64_t) irel->r_offset);
9975 return FALSE;
9976 }
9977
9978 /* Get the value of the symbol referred to by the reloc. */
9979 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
9980
9981 if (foff == 0
9982 || foff < -CONSERVATIVE_24BIT_S1
9983 || foff >= CONSERVATIVE_24BIT_S1)
9984 return FALSE;
9985
9986 insn = bfd_getb32 (contents + laddr);
9987 if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
9988 {
9989 /* Relax to bgezal rt, label ; 17_PCREL
9990 or bltzal rt, label ; 17_PCREL */
9991
9992 /* Convert to complimentary conditional call. */
9993 insn = CONVERT_CONDITION_CALL (insn);
9994 bfd_putb32 (insn, contents + irel->r_offset);
9995
9996 *insn_len = 4;
9997 irel->r_info =
9998 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9999 hi_irelfn->r_info =
10000 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
10001 lo_irelfn->r_info =
10002 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
10003
10004 cond_irelfn =
10005 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10006 R_NDS32_17_PCREL_RELA, laddr);
10007 if (cond_irelfn != irelend)
10008 {
10009 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10010 R_NDS32_17_PCREL_RELA);
10011 cond_irelfn->r_addend = hi_irelfn->r_addend;
10012 }
10013
10014 if (seq_len & 0x2)
10015 {
10016 insn16 = NDS32_NOP16;
10017 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10018 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10019 R_NDS32_INSN16);
10020 hi_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10021 insn_len += 2;
10022 }
10023 }
10024 else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
10025 {
10026 /* Relax to the following instruction sequence
10027 bltz rt, $1 ; LONGCALL2
10028 jal symbol ; 25_PCREL
10029 $1 */
10030 *insn_len = 8;
10031 insn = INSN_JAL;
10032 bfd_putb32 (insn, contents + hi_irelfn->r_offset);
10033
10034 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10035 R_NDS32_25_PCREL_RELA);
10036 irel->r_info =
10037 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL2);
10038
10039 lo_irelfn->r_info =
10040 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
10041
10042 if (seq_len & 0x2)
10043 {
10044 insn16 = NDS32_NOP16;
10045 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10046 lo_irelfn->r_info =
10047 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
10048 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10049 insn_len += 2;
10050 }
10051 }
10052 return TRUE;
10053 }
10054
10055 /* Relax LONGJUMP1 relocation for nds32_elf_relax_section. */
10056
10057 static bfd_boolean
10058 nds32_elf_relax_longjump1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10059 Elf_Internal_Rela *internal_relocs, int *insn_len,
10060 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10061 Elf_Internal_Shdr *symtab_hdr)
10062 {
10063 /* There are 3 variations for LONGJUMP1
10064 case 4-4-2; 16-bit bit on, optimize off or optimize for space
10065 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
10066 ori ta, ta, lo12(symbol) ; LO12S0
10067 jr5 ta ;
10068
10069 case 4-4-4; 16-bit off, optimize don't care
10070 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
10071 ori ta, ta, lo12(symbol) ; LO12S0
10072 jr ta ;
10073
10074 case 4-4-4; 16-bit on, optimize for speed
10075 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
10076 ori ta, ta, lo12(symbol) ; LO12S0
10077 jr ta ; */
10078
10079 /* Get the reloc for the address from which the register is
10080 being loaded. This reloc will tell us which function is
10081 actually being called. */
10082
10083 bfd_vma laddr;
10084 int seq_len; /* Original length of instruction sequence. */
10085 int insn16_on; /* 16-bit on/off. */
10086 uint32_t insn;
10087 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
10088 bfd_signed_vma foff;
10089 uint16_t insn16;
10090 unsigned long reloc;
10091
10092 irelend = internal_relocs + sec->reloc_count;
10093 seq_len = GET_SEQ_LEN (irel->r_addend);
10094 laddr = irel->r_offset;
10095 *insn_len = seq_len;
10096 insn16_on = IS_16BIT_ON (irel->r_addend);
10097
10098 hi_irelfn =
10099 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10100 R_NDS32_HI20_RELA, laddr);
10101 lo_irelfn =
10102 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10103 R_NDS32_LO12S0_ORI_RELA, laddr + 4);
10104 if (hi_irelfn == irelend || lo_irelfn == irelend)
10105 {
10106 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP1",
10107 (uint64_t) irel->r_offset);
10108 return FALSE;
10109 }
10110
10111 /* Get the value of the symbol referred to by the reloc. */
10112 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
10113
10114 if (foff == 0
10115 || foff >= CONSERVATIVE_24BIT_S1
10116 || foff < -CONSERVATIVE_24BIT_S1)
10117 return FALSE;
10118
10119 if (insn16_on
10120 && foff >= -ACCURATE_8BIT_S1
10121 && foff < ACCURATE_8BIT_S1
10122 && (seq_len & 0x2))
10123 {
10124 /* j8 label */
10125 /* 16-bit on, but not optimized for speed. */
10126 reloc = R_NDS32_9_PCREL_RELA;
10127 insn16 = INSN_J8;
10128 bfd_putb16 (insn16, contents + irel->r_offset);
10129 *insn_len = 2;
10130 irel->r_info =
10131 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10132 }
10133 else
10134 {
10135 /* j label */
10136 reloc = R_NDS32_25_PCREL_RELA;
10137 insn = INSN_J;
10138 bfd_putb32 (insn, contents + irel->r_offset);
10139 *insn_len = 4;
10140 irel->r_info =
10141 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_INSN16);
10142 irel->r_addend = 0;
10143 }
10144
10145 hi_irelfn->r_info =
10146 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
10147 lo_irelfn->r_info =
10148 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
10149
10150 if ((seq_len & 0x2) && ((*insn_len & 2) == 0))
10151 {
10152 insn16 = NDS32_NOP16;
10153 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10154 lo_irelfn->r_info =
10155 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
10156 R_NDS32_INSN16);
10157 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10158 *insn_len += 2;
10159 }
10160 return TRUE;
10161 }
10162
10163 /* Revert condition branch. This function does not check if the input
10164 instruction is condition branch or not. */
10165
10166 static void
10167 nds32_elf_convert_branch (uint16_t insn16, uint32_t insn,
10168 uint16_t *re_insn16, uint32_t *re_insn)
10169 {
10170 uint32_t comp_insn = 0;
10171 uint16_t comp_insn16 = 0;
10172
10173 if (insn)
10174 {
10175 if (N32_OP6 (insn) == N32_OP6_BR1)
10176 {
10177 /* beqs label. */
10178 comp_insn = (insn ^ 0x4000) & 0xffffc000;
10179 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5)
10180 {
10181 /* Insn can be contracted to 16-bit implied r5. */
10182 comp_insn16 =
10183 (comp_insn & 0x4000) ? INSN_BNES38 : INSN_BEQS38;
10184 comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
10185 }
10186 }
10187 else if (N32_OP6 (insn) == N32_OP6_BR3)
10188 {
10189 /* bnec $ta, imm11, label. */
10190 comp_insn = (insn ^ 0x80000) & 0xffffff00;
10191 }
10192 else
10193 {
10194 comp_insn = (insn ^ 0x10000) & 0xffffc000;
10195 if (N32_BR2_SUB (insn) == N32_BR2_BEQZ
10196 || N32_BR2_SUB (insn) == N32_BR2_BNEZ)
10197 {
10198 if (N32_IS_RT3 (insn))
10199 {
10200 /* Insn can be contracted to 16-bit. */
10201 comp_insn16 =
10202 (comp_insn & 0x10000) ? INSN_BNEZ38 : INSN_BEQZ38;
10203 comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
10204 }
10205 else if (N32_RT5 (insn) == REG_R15)
10206 {
10207 /* Insn can be contracted to 16-bit. */
10208 comp_insn16 =
10209 (comp_insn & 0x10000) ? INSN_BNES38 : INSN_BEQS38;
10210 }
10211 }
10212 }
10213 }
10214 else
10215 {
10216 switch ((insn16 & 0xf000) >> 12)
10217 {
10218 case 0xc:
10219 /* beqz38 or bnez38 */
10220 comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
10221 comp_insn = (comp_insn16 & 0x0800) ? INSN_BNEZ : INSN_BEQZ;
10222 comp_insn |= ((comp_insn16 & 0x0700) >> 8) << 20;
10223 break;
10224
10225 case 0xd:
10226 /* beqs38 or bnes38 */
10227 comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
10228 comp_insn = (comp_insn16 & 0x0800) ? INSN_BNE : INSN_BEQ;
10229 comp_insn |= (((comp_insn16 & 0x0700) >> 8) << 20)
10230 | (REG_R5 << 15);
10231 break;
10232
10233 case 0xe:
10234 /* beqzS8 or bnezS8 */
10235 comp_insn16 = (insn16 ^ 0x0100) & 0xff00;
10236 comp_insn = (comp_insn16 & 0x0100) ? INSN_BNEZ : INSN_BEQZ;
10237 comp_insn |= REG_R15 << 20;
10238 break;
10239
10240 default:
10241 break;
10242 }
10243 }
10244 if (comp_insn && re_insn)
10245 *re_insn = comp_insn;
10246 if (comp_insn16 && re_insn16)
10247 *re_insn16 = comp_insn16;
10248 }
10249
10250 /* Relax LONGJUMP2 relocation for nds32_elf_relax_section. */
10251
10252 static bfd_boolean
10253 nds32_elf_relax_longjump2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10254 Elf_Internal_Rela *internal_relocs, int *insn_len,
10255 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10256 Elf_Internal_Shdr *symtab_hdr)
10257 {
10258 /* There are 3 variations for LONGJUMP2
10259 case 2-4; 1st insn convertible, 16-bit on,
10260 optimize off or optimize for space
10261 bnes38 rt, ra, $1 ; LONGJUMP2
10262 j label ; 25_PCREL
10263 $1:
10264
10265 case 4-4; 1st insn not convertible
10266 bne rt, ra, $1 ; LONGJUMP2
10267 j label ; 25_PCREL
10268 $1:
10269
10270 case 4-4; 1st insn convertible, 16-bit on, optimize for speed
10271 bne rt, ra, $1 ; LONGJUMP2
10272 j label ; 25_PCREL
10273 $1: */
10274
10275 /* Get the reloc for the address from which the register is
10276 being loaded. This reloc will tell us which function is
10277 actually being called. */
10278
10279 bfd_vma laddr;
10280 int seq_len; /* Original length of instruction sequence. */
10281 Elf_Internal_Rela *i2_irelfn, *cond_irelfn, *irelend;
10282 int first_size;
10283 unsigned int i;
10284 bfd_signed_vma foff;
10285 uint32_t insn, re_insn = 0;
10286 uint16_t insn16, re_insn16 = 0;
10287 unsigned long reloc, cond_reloc;
10288
10289 enum elf_nds32_reloc_type checked_types[] =
10290 { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
10291
10292 irelend = internal_relocs + sec->reloc_count;
10293 seq_len = GET_SEQ_LEN (irel->r_addend);
10294 laddr = irel->r_offset;
10295 *insn_len = seq_len;
10296 first_size = (seq_len == 6) ? 2 : 4;
10297
10298 i2_irelfn =
10299 find_relocs_at_address_addr (irel, internal_relocs,
10300 irelend, R_NDS32_25_PCREL_RELA,
10301 laddr + first_size);
10302
10303 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
10304 {
10305 cond_irelfn =
10306 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10307 checked_types[i], laddr);
10308 if (cond_irelfn != irelend)
10309 break;
10310 }
10311
10312 if (i2_irelfn == irelend || cond_irelfn == irelend)
10313 {
10314 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP2",
10315 (uint64_t) irel->r_offset);
10316 return FALSE;
10317 }
10318
10319 /* Get the value of the symbol referred to by the reloc. */
10320 foff = calculate_offset (abfd, sec, i2_irelfn, isymbuf, symtab_hdr);
10321 if (foff == 0
10322 || foff < -CONSERVATIVE_16BIT_S1
10323 || foff >= CONSERVATIVE_16BIT_S1)
10324 return FALSE;
10325
10326 /* Get the all corresponding instructions. */
10327 if (first_size == 4)
10328 {
10329 insn = bfd_getb32 (contents + laddr);
10330 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10331 }
10332 else
10333 {
10334 insn16 = bfd_getb16 (contents + laddr);
10335 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10336 }
10337
10338 if (re_insn16 && foff >= -(ACCURATE_8BIT_S1 - first_size)
10339 && foff < ACCURATE_8BIT_S1 - first_size)
10340 {
10341 if (first_size == 4)
10342 {
10343 /* Don't convert it to 16-bit now, keep this as relaxable for
10344 ``label reloc; INSN16''. */
10345
10346 /* Save comp_insn32 to buffer. */
10347 bfd_putb32 (re_insn, contents + irel->r_offset);
10348 *insn_len = 4;
10349 reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
10350 R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
10351 cond_reloc = R_NDS32_INSN16;
10352 }
10353 else
10354 {
10355 bfd_putb16 (re_insn16, contents + irel->r_offset);
10356 *insn_len = 2;
10357 reloc = R_NDS32_9_PCREL_RELA;
10358 cond_reloc = R_NDS32_NONE;
10359 }
10360 }
10361 else if (N32_OP6 (re_insn) == N32_OP6_BR1
10362 && (foff >= -(ACCURATE_14BIT_S1 - first_size)
10363 && foff < ACCURATE_14BIT_S1 - first_size))
10364 {
10365 /* beqs label ; 15_PCREL */
10366 bfd_putb32 (re_insn, contents + irel->r_offset);
10367 *insn_len = 4;
10368 reloc = R_NDS32_15_PCREL_RELA;
10369 cond_reloc = R_NDS32_NONE;
10370 }
10371 else if (N32_OP6 (re_insn) == N32_OP6_BR2
10372 && foff >= -CONSERVATIVE_16BIT_S1
10373 && foff < CONSERVATIVE_16BIT_S1)
10374 {
10375 /* beqz label ; 17_PCREL */
10376 bfd_putb32 (re_insn, contents + irel->r_offset);
10377 *insn_len = 4;
10378 reloc = R_NDS32_17_PCREL_RELA;
10379 cond_reloc = R_NDS32_NONE;
10380 }
10381 else
10382 return FALSE;
10383
10384 /* Set all relocations. */
10385 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info), reloc);
10386 irel->r_addend = i2_irelfn->r_addend;
10387
10388 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
10389 cond_reloc);
10390 cond_irelfn->r_addend = 0;
10391
10392 if ((seq_len ^ *insn_len ) & 0x2)
10393 {
10394 insn16 = NDS32_NOP16;
10395 bfd_putb16 (insn16, contents + irel->r_offset + 4);
10396 i2_irelfn->r_offset = 4;
10397 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
10398 R_NDS32_INSN16);
10399 i2_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10400 *insn_len += 2;
10401 }
10402 else
10403 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
10404 R_NDS32_NONE);
10405 return TRUE;
10406 }
10407
10408 /* Relax LONGJUMP3 relocation for nds32_elf_relax_section. */
10409
10410 static bfd_boolean
10411 nds32_elf_relax_longjump3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10412 Elf_Internal_Rela *internal_relocs, int *insn_len,
10413 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10414 Elf_Internal_Shdr *symtab_hdr)
10415 {
10416 /* There are 5 variations for LONGJUMP3
10417 case 1: 2-4-4-2; 1st insn convertible, 16-bit on,
10418 optimize off or optimize for space
10419 bnes38 rt, ra, $1 ; LONGJUMP3
10420 sethi ta, hi20(symbol) ; HI20
10421 ori ta, ta, lo12(symbol) ; LO12S0
10422 jr5 ta ;
10423 $1: ;
10424
10425 case 2: 2-4-4-2; 1st insn convertible, 16-bit on, optimize for speed
10426 bnes38 rt, ra, $1 ; LONGJUMP3
10427 sethi ta, hi20(symbol) ; HI20
10428 ori ta, ta, lo12(symbol) ; LO12S0
10429 jr5 ta ;
10430 $1: ; LABEL
10431
10432 case 3: 4-4-4-2; 1st insn not convertible, 16-bit on,
10433 optimize off or optimize for space
10434 bne rt, ra, $1 ; LONGJUMP3
10435 sethi ta, hi20(symbol) ; HI20
10436 ori ta, ta, lo12(symbol) ; LO12S0
10437 jr5 ta ;
10438 $1: ;
10439
10440 case 4: 4-4-4-4; 1st insn don't care, 16-bit off, optimize don't care
10441 16-bit off if no INSN16
10442 bne rt, ra, $1 ; LONGJUMP3
10443 sethi ta, hi20(symbol) ; HI20
10444 ori ta, ta, lo12(symbol) ; LO12S0
10445 jr ta ;
10446 $1: ;
10447
10448 case 5: 4-4-4-4; 1st insn not convertible, 16-bit on, optimize for speed
10449 16-bit off if no INSN16
10450 bne rt, ra, $1 ; LONGJUMP3
10451 sethi ta, hi20(symbol) ; HI20
10452 ori ta, ta, lo12(symbol) ; LO12S0
10453 jr ta ;
10454 $1: ; LABEL */
10455
10456 /* Get the reloc for the address from which the register is
10457 being loaded. This reloc will tell us which function is
10458 actually being called. */
10459 enum elf_nds32_reloc_type checked_types[] =
10460 { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
10461
10462 int reloc_off = 0, cond_removed = 0, convertible;
10463 bfd_vma laddr;
10464 int seq_len; /* Original length of instruction sequence. */
10465 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
10466 int first_size;
10467 unsigned int i;
10468 bfd_signed_vma foff;
10469 uint32_t insn, re_insn = 0;
10470 uint16_t insn16, re_insn16 = 0;
10471 unsigned long reloc, cond_reloc;
10472
10473 irelend = internal_relocs + sec->reloc_count;
10474 seq_len = GET_SEQ_LEN (irel->r_addend);
10475 laddr = irel->r_offset;
10476 *insn_len = seq_len;
10477
10478 convertible = IS_1ST_CONVERT (irel->r_addend);
10479
10480 if (convertible)
10481 first_size = 2;
10482 else
10483 first_size = 4;
10484
10485 /* Get all needed relocations. */
10486 hi_irelfn =
10487 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10488 R_NDS32_HI20_RELA, laddr + first_size);
10489 lo_irelfn =
10490 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10491 R_NDS32_LO12S0_ORI_RELA,
10492 laddr + first_size + 4);
10493
10494 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
10495 {
10496 cond_irelfn =
10497 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10498 checked_types[i], laddr);
10499 if (cond_irelfn != irelend)
10500 break;
10501 }
10502
10503 if (hi_irelfn == irelend
10504 || lo_irelfn == irelend
10505 || cond_irelfn == irelend)
10506 {
10507 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP3",
10508 (uint64_t) irel->r_offset);
10509 return FALSE;
10510 }
10511
10512 /* Get the value of the symbol referred to by the reloc. */
10513 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
10514
10515 if (foff == 0
10516 || foff < -CONSERVATIVE_24BIT_S1
10517 || foff >= CONSERVATIVE_24BIT_S1)
10518 return FALSE;
10519
10520 /* Get the all corresponding instructions. */
10521 if (first_size == 4)
10522 {
10523 insn = bfd_getb32 (contents + laddr);
10524 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10525 }
10526 else
10527 {
10528 insn16 = bfd_getb16 (contents + laddr);
10529 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10530 }
10531
10532 /* For simplicity of coding, we are going to modify the section
10533 contents, the section relocs, and the BFD symbol table. We
10534 must tell the rest of the code not to free up this
10535 information. It would be possible to instead create a table
10536 of changes which have to be made, as is done in coff-mips.c;
10537 that would be more work, but would require less memory when
10538 the linker is run. */
10539
10540 if (re_insn16
10541 && foff >= -ACCURATE_8BIT_S1 - first_size
10542 && foff < ACCURATE_8BIT_S1 - first_size)
10543 {
10544 if (!(seq_len & 0x2))
10545 {
10546 /* Don't convert it to 16-bit now, keep this as relaxable
10547 for ``label reloc; INSN1a''6. */
10548 /* Save comp_insn32 to buffer. */
10549 bfd_putb32 (re_insn, contents + irel->r_offset);
10550 *insn_len = 4;
10551 reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
10552 R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
10553 cond_reloc = R_NDS32_INSN16;
10554 }
10555 else
10556 {
10557 /* Not optimize for speed; convert sequence to 16-bit. */
10558 /* Save comp_insn16 to buffer. */
10559 bfd_putb16 (re_insn16, contents + irel->r_offset);
10560 *insn_len = 2;
10561 reloc = R_NDS32_9_PCREL_RELA;
10562 cond_reloc = R_NDS32_NONE;
10563 }
10564 cond_removed = 1;
10565 }
10566 else if (N32_OP6 (re_insn) == N32_OP6_BR1
10567 && (foff >= -(ACCURATE_14BIT_S1 - first_size)
10568 && foff < ACCURATE_14BIT_S1 - first_size))
10569 {
10570 /* beqs label ; 15_PCREL */
10571 bfd_putb32 (re_insn, contents + irel->r_offset);
10572 *insn_len = 4;
10573 reloc = R_NDS32_15_PCREL_RELA;
10574 cond_reloc = R_NDS32_NONE;
10575 cond_removed = 1;
10576 }
10577 else if (N32_OP6 (re_insn) == N32_OP6_BR2
10578 && foff >= -CONSERVATIVE_16BIT_S1
10579 && foff < CONSERVATIVE_16BIT_S1)
10580 {
10581 /* beqz label ; 17_PCREL */
10582 bfd_putb32 (re_insn, contents + irel->r_offset);
10583 *insn_len = 4;
10584 reloc = R_NDS32_17_PCREL_RELA;
10585 cond_reloc = R_NDS32_NONE;
10586 cond_removed = 1;
10587 }
10588 else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
10589 && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
10590 {
10591 /* Relax to one of the following 3 variations
10592
10593 case 2-4; 1st insn convertible, 16-bit on, optimize off or optimize
10594 for space
10595 bnes38 rt, $1 ; LONGJUMP2
10596 j label ; 25_PCREL
10597 $1
10598
10599 case 4-4; 1st insn not convertible, others don't care
10600 bne rt, ra, $1 ; LONGJUMP2
10601 j label ; 25_PCREL
10602 $1
10603
10604 case 4-4; 1st insn convertible, 16-bit on, optimize for speed
10605 bne rt, ra, $1 ; LONGJUMP2
10606 j label ; 25_PCREL
10607 $1 */
10608
10609 /* Offset for first instruction. */
10610
10611 /* Use j label as second instruction. */
10612 *insn_len = 4 + first_size;
10613 insn = INSN_J;
10614 bfd_putb32 (insn, contents + hi_irelfn->r_offset);
10615 reloc = R_NDS32_LONGJUMP2;
10616 cond_reloc = R_NDS32_25_PLTREL;
10617 }
10618 else
10619 return FALSE;
10620
10621 if (cond_removed == 1)
10622 {
10623 /* Set all relocations. */
10624 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
10625 irel->r_addend = hi_irelfn->r_addend;
10626
10627 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
10628 cond_reloc);
10629 cond_irelfn->r_addend = 0;
10630 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10631 R_NDS32_NONE);
10632 }
10633 else
10634 {
10635 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
10636 irel->r_addend = irel->r_addend;
10637 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10638 cond_reloc);
10639 }
10640
10641 if ((seq_len ^ *insn_len ) & 0x2)
10642 {
10643 insn16 = NDS32_NOP16;
10644 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10645 lo_irelfn->r_offset = *insn_len;
10646 lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
10647 R_NDS32_INSN16);
10648 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10649 *insn_len += 2;
10650 }
10651 else
10652 lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
10653 R_NDS32_NONE);
10654 return TRUE;
10655 }
10656
10657 /* Relax LONGCALL4 relocation for nds32_elf_relax_section. */
10658
10659 static bfd_boolean
10660 nds32_elf_relax_longcall4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10661 Elf_Internal_Rela *internal_relocs, int *insn_len,
10662 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10663 Elf_Internal_Shdr *symtab_hdr)
10664 {
10665 /* The pattern for LONGCALL4. Support for function cse.
10666 sethi ta, hi20(symbol) ; LONGCALL4/HI20
10667 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10668 jral ta ; PTR_RES/EMPTY/INSN16 */
10669
10670 bfd_vma laddr;
10671 uint32_t insn;
10672 Elf_Internal_Rela *hi_irel, *ptr_irel, *insn_irel, *em_irel, *call_irel;
10673 Elf_Internal_Rela *irelend;
10674 bfd_signed_vma foff;
10675
10676 irelend = internal_relocs + sec->reloc_count;
10677 laddr = irel->r_offset;
10678
10679 /* Get the reloc for the address from which the register is
10680 being loaded. This reloc will tell us which function is
10681 actually being called. */
10682 hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10683 R_NDS32_HI20_RELA, laddr);
10684
10685 if (hi_irel == irelend)
10686 {
10687 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL4",
10688 (uint64_t) irel->r_offset);
10689 return FALSE;
10690 }
10691
10692 /* Get the value of the symbol referred to by the reloc. */
10693 foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr);
10694
10695 /* This condition only happened when symbol is undefined. */
10696 if (foff == 0
10697 || foff < -CONSERVATIVE_24BIT_S1
10698 || foff >= CONSERVATIVE_24BIT_S1)
10699 return FALSE;
10700
10701 /* Relax to: jal symbol; 25_PCREL. */
10702 /* For simplicity of coding, we are going to modify the section
10703 contents, the section relocs, and the BFD symbol table. We
10704 must tell the rest of the code not to free up this
10705 information. It would be possible to instead create a table
10706 of changes which have to be made, as is done in coff-mips.c;
10707 that would be more work, but would require less memory when
10708 the linker is run. */
10709
10710 ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10711 R_NDS32_PTR_RESOLVED, irel->r_addend);
10712 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10713 R_NDS32_EMPTY, irel->r_addend);
10714
10715 if (ptr_irel == irelend || em_irel == irelend)
10716 {
10717 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL4",
10718 (uint64_t) irel->r_offset);
10719 return FALSE;
10720 }
10721 /* Check these is enough space to insert jal in R_NDS32_EMPTY. */
10722 insn = bfd_getb32 (contents + irel->r_addend);
10723 if (insn & 0x80000000)
10724 return FALSE;
10725
10726 /* Replace the long call with a jal. */
10727 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10728 R_NDS32_25_PCREL_RELA);
10729 ptr_irel->r_addend = 1;
10730
10731 /* We don't resolve this here but resolve it in relocate_section. */
10732 insn = INSN_JAL;
10733 bfd_putb32 (insn, contents + em_irel->r_offset);
10734
10735 irel->r_info =
10736 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10737
10738 /* If there is function cse, HI20 can not remove now. */
10739 call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10740 R_NDS32_LONGCALL4, laddr);
10741 if (call_irel == irelend)
10742 {
10743 *insn_len = 0;
10744 hi_irel->r_info =
10745 ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10746 }
10747
10748 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10749 R_NDS32_INSN16, irel->r_addend);
10750 if (insn_irel != irelend)
10751 insn_irel->r_info =
10752 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10753
10754 return TRUE;
10755 }
10756
10757 /* Relax LONGCALL5 relocation for nds32_elf_relax_section. */
10758
10759 static bfd_boolean
10760 nds32_elf_relax_longcall5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10761 Elf_Internal_Rela *internal_relocs, int *insn_len,
10762 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10763 Elf_Internal_Shdr *symtab_hdr)
10764 {
10765 /* The pattern for LONGCALL5.
10766 bltz rt, .L1 ; LONGCALL5/17_PCREL
10767 jal symbol ; 25_PCREL
10768 .L1: */
10769
10770 bfd_vma laddr;
10771 uint32_t insn;
10772 Elf_Internal_Rela *cond_irel, *irelend;
10773 bfd_signed_vma foff;
10774
10775 irelend = internal_relocs + sec->reloc_count;
10776 laddr = irel->r_offset;
10777 insn = bfd_getb32 (contents + laddr);
10778
10779 /* Get the reloc for the address from which the register is
10780 being loaded. This reloc will tell us which function is
10781 actually being called. */
10782 cond_irel =
10783 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10784 R_NDS32_25_PCREL_RELA, irel->r_addend);
10785 if (cond_irel == irelend)
10786 {
10787 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL5",
10788 (uint64_t) irel->r_offset);
10789 return FALSE;
10790 }
10791
10792 /* Get the value of the symbol referred to by the reloc. */
10793 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr);
10794
10795 if (foff == 0
10796 || foff < -CONSERVATIVE_16BIT_S1
10797 || foff >= CONSERVATIVE_16BIT_S1)
10798 return FALSE;
10799
10800 /* Relax to bgezal rt, label ; 17_PCREL
10801 or bltzal rt, label ; 17_PCREL. */
10802
10803 /* Convert to complimentary conditional call. */
10804 insn = CONVERT_CONDITION_CALL (insn);
10805
10806 /* For simplicity of coding, we are going to modify the section
10807 contents, the section relocs, and the BFD symbol table. We
10808 must tell the rest of the code not to free up this
10809 information. It would be possible to instead create a table
10810 of changes which have to be made, as is done in coff-mips.c;
10811 that would be more work, but would require less memory when
10812 the linker is run. */
10813
10814 /* Modify relocation and contents. */
10815 cond_irel->r_info =
10816 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_17_PCREL_RELA);
10817
10818 /* Replace the long call with a bgezal. */
10819 bfd_putb32 (insn, contents + cond_irel->r_offset);
10820 *insn_len = 0;
10821
10822 /* Clean unnessary relocations. */
10823 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10824
10825 cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10826 R_NDS32_17_PCREL_RELA, laddr);
10827 cond_irel->r_info =
10828 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10829
10830 return TRUE;
10831 }
10832
10833 /* Relax LONGCALL6 relocation for nds32_elf_relax_section. */
10834
10835 static bfd_boolean
10836 nds32_elf_relax_longcall6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10837 Elf_Internal_Rela *internal_relocs, int *insn_len,
10838 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10839 Elf_Internal_Shdr *symtab_hdr)
10840 {
10841 /* The pattern for LONGCALL6.
10842 bltz rt, .L1 ; LONGCALL6/17_PCREL
10843 sethi ta, hi20(symbol) ; HI20/PTR
10844 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10845 jral ta ; PTR_RES/EMPTY/INSN16
10846 .L1 */
10847
10848 bfd_vma laddr;
10849 uint32_t insn;
10850 Elf_Internal_Rela *em_irel, *cond_irel, *irelend;
10851 bfd_signed_vma foff;
10852
10853 irelend = internal_relocs + sec->reloc_count;
10854 laddr = irel->r_offset;
10855
10856 /* Get the reloc for the address from which the register is
10857 being loaded. This reloc will tell us which function is
10858 actually being called. */
10859 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10860 R_NDS32_EMPTY, irel->r_addend);
10861
10862 if (em_irel == irelend)
10863 {
10864 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL6",
10865 (uint64_t) irel->r_offset);
10866 return FALSE;
10867 }
10868
10869 /* Get the value of the symbol referred to by the reloc. */
10870 foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr);
10871
10872 if (foff == 0
10873 || foff < -CONSERVATIVE_24BIT_S1
10874 || foff >= CONSERVATIVE_24BIT_S1)
10875 return FALSE;
10876
10877 /* Check these is enough space to insert jal in R_NDS32_EMPTY. */
10878 insn = bfd_getb32 (contents + irel->r_addend);
10879 if (insn & 0x80000000)
10880 return FALSE;
10881
10882 insn = bfd_getb32 (contents + laddr);
10883 if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10884 {
10885 /* Relax to bgezal rt, label ; 17_PCREL
10886 or bltzal rt, label ; 17_PCREL. */
10887
10888 /* Convert to complimentary conditional call. */
10889 *insn_len = 0;
10890 insn = CONVERT_CONDITION_CALL (insn);
10891 bfd_putb32 (insn, contents + em_irel->r_offset);
10892
10893 em_irel->r_info =
10894 ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_17_PCREL_RELA);
10895
10896 /* Set resolved relocation. */
10897 cond_irel =
10898 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10899 R_NDS32_PTR_RESOLVED, irel->r_addend);
10900 if (cond_irel == irelend)
10901 {
10902 _bfd_error_handler (unrecognized_reloc_msg, abfd,
10903 "R_NDS32_LONGCALL6", (uint64_t) irel->r_offset);
10904 return FALSE;
10905 }
10906 cond_irel->r_addend = 1;
10907
10908 /* Clear relocations. */
10909
10910 irel->r_info =
10911 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10912
10913 cond_irel =
10914 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10915 R_NDS32_17_PCREL_RELA, laddr);
10916 if (cond_irel != irelend)
10917 cond_irel->r_info =
10918 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10919
10920 cond_irel =
10921 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10922 R_NDS32_INSN16, irel->r_addend);
10923 if (cond_irel != irelend)
10924 cond_irel->r_info =
10925 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10926
10927 }
10928 else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
10929 {
10930 /* Relax to the following instruction sequence
10931 bltz rt, .L1 ; LONGCALL2/17_PCREL
10932 jal symbol ; 25_PCREL/PTR_RES
10933 .L1 */
10934 *insn_len = 4;
10935 /* Convert instruction. */
10936 insn = INSN_JAL;
10937 bfd_putb32 (insn, contents + em_irel->r_offset);
10938
10939 /* Convert relocations. */
10940 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10941 R_NDS32_25_PCREL_RELA);
10942 irel->r_info =
10943 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL5);
10944
10945 /* Set resolved relocation. */
10946 cond_irel =
10947 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10948 R_NDS32_PTR_RESOLVED, irel->r_addend);
10949 if (cond_irel == irelend)
10950 {
10951 _bfd_error_handler (unrecognized_reloc_msg, abfd,
10952 "R_NDS32_LONGCALL6", (uint64_t) irel->r_offset);
10953 return FALSE;
10954 }
10955 cond_irel->r_addend = 1;
10956
10957 cond_irel =
10958 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10959 R_NDS32_INSN16, irel->r_addend);
10960 if (cond_irel != irelend)
10961 cond_irel->r_info =
10962 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10963 }
10964 return TRUE;
10965 }
10966
10967 /* Relax LONGJUMP4 relocation for nds32_elf_relax_section. */
10968
10969 static bfd_boolean
10970 nds32_elf_relax_longjump4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10971 Elf_Internal_Rela *internal_relocs, int *insn_len,
10972 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10973 Elf_Internal_Shdr *symtab_hdr)
10974 {
10975 /* The pattern for LONGJUMP4.
10976 sethi ta, hi20(symbol) ; LONGJUMP4/HI20
10977 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10978 jr ta ; PTR_RES/INSN16/EMPTY */
10979
10980 bfd_vma laddr;
10981 int seq_len; /* Original length of instruction sequence. */
10982 uint32_t insn;
10983 Elf_Internal_Rela *hi_irel, *ptr_irel, *em_irel, *call_irel, *irelend;
10984 bfd_signed_vma foff;
10985
10986 irelend = internal_relocs + sec->reloc_count;
10987 seq_len = GET_SEQ_LEN (irel->r_addend);
10988 laddr = irel->r_offset;
10989 *insn_len = seq_len;
10990
10991 /* Get the reloc for the address from which the register is
10992 being loaded. This reloc will tell us which function is
10993 actually being called. */
10994
10995 hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10996 R_NDS32_HI20_RELA, laddr);
10997
10998 if (hi_irel == irelend)
10999 {
11000 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP4",
11001 (uint64_t) irel->r_offset);
11002 return FALSE;
11003 }
11004
11005 /* Get the value of the symbol referred to by the reloc. */
11006 foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr);
11007
11008 if (foff == 0
11009 || foff >= CONSERVATIVE_24BIT_S1
11010 || foff < -CONSERVATIVE_24BIT_S1)
11011 return FALSE;
11012
11013 /* Convert it to "j label", it may be converted to j8 in the final
11014 pass of relaxation. Therefore, we do not consider this currently. */
11015 ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11016 R_NDS32_PTR_RESOLVED, irel->r_addend);
11017 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11018 R_NDS32_EMPTY, irel->r_addend);
11019
11020 if (ptr_irel == irelend || em_irel == irelend)
11021 {
11022 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP4",
11023 (uint64_t) irel->r_offset);
11024 return FALSE;
11025 }
11026
11027 em_irel->r_info =
11028 ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_25_PCREL_RELA);
11029 ptr_irel->r_addend = 1;
11030
11031 /* Write instruction. */
11032 insn = INSN_J;
11033 bfd_putb32 (insn, contents + em_irel->r_offset);
11034
11035 /* Clear relocations. */
11036 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11037
11038 /* If there is function cse, HI20 can not remove now. */
11039 call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11040 R_NDS32_LONGJUMP4, laddr);
11041 if (call_irel == irelend)
11042 {
11043 *insn_len = 0;
11044 hi_irel->r_info =
11045 ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
11046 }
11047
11048 return TRUE;
11049 }
11050
11051 /* Relax LONGJUMP5 relocation for nds32_elf_relax_section. */
11052
11053 static bfd_boolean
11054 nds32_elf_relax_longjump5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11055 Elf_Internal_Rela *internal_relocs, int *insn_len,
11056 int *seq_len, bfd_byte *contents,
11057 Elf_Internal_Sym *isymbuf,
11058 Elf_Internal_Shdr *symtab_hdr)
11059 {
11060 /* There are 2 variations for LONGJUMP5
11061 case 2-4; 1st insn convertible, 16-bit on.
11062 bnes38 rt, ra, .L1 ; LONGJUMP5/9_PCREL/INSN16
11063 j label ; 25_PCREL/INSN16
11064 $1:
11065
11066 case 4-4; 1st insn not convertible
11067 bne rt, ra, .L1 ; LONGJUMP5/15_PCREL/INSN16
11068 j label ; 25_PCREL/INSN16
11069 .L1: */
11070
11071 bfd_vma laddr;
11072 Elf_Internal_Rela *cond_irel, *irelend;
11073 unsigned int i;
11074 bfd_signed_vma foff;
11075 uint32_t insn, re_insn = 0;
11076 uint16_t insn16, re_insn16 = 0;
11077 unsigned long reloc;
11078
11079 enum elf_nds32_reloc_type checked_types[] =
11080 { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
11081 R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
11082
11083 irelend = internal_relocs + sec->reloc_count;
11084 laddr = irel->r_offset;
11085
11086 /* Get the reloc for the address from which the register is
11087 being loaded. This reloc will tell us which function is
11088 actually being called. */
11089
11090 cond_irel =
11091 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11092 R_NDS32_25_PCREL_RELA, irel->r_addend);
11093 if (cond_irel == irelend)
11094 {
11095 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP5",
11096 (uint64_t) irel->r_offset);
11097 return FALSE;
11098 }
11099
11100 /* Get the value of the symbol referred to by the reloc. */
11101 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr);
11102
11103 if (foff == 0
11104 || foff < -CONSERVATIVE_16BIT_S1
11105 || foff >= CONSERVATIVE_16BIT_S1)
11106 return FALSE;
11107
11108 /* Get the all corresponding instructions. */
11109 insn = bfd_getb32 (contents + laddr);
11110 /* Check instruction size. */
11111 if (insn & 0x80000000)
11112 {
11113 *seq_len = 0;
11114 insn16 = insn >> 16;
11115 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
11116 }
11117 else
11118 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
11119
11120 if (N32_OP6 (re_insn) == N32_OP6_BR1
11121 && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
11122 {
11123 /* beqs label ; 15_PCREL. */
11124 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11125 reloc = R_NDS32_15_PCREL_RELA;
11126 }
11127 else if (N32_OP6 (re_insn) == N32_OP6_BR2
11128 && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
11129 {
11130 /* beqz label ; 17_PCREL. */
11131 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11132 reloc = R_NDS32_17_PCREL_RELA;
11133 }
11134 else if ( N32_OP6 (re_insn) == N32_OP6_BR3
11135 && foff >= -CONSERVATIVE_8BIT_S1 && foff < CONSERVATIVE_8BIT_S1)
11136 {
11137 /* beqc label ; 9_PCREL. */
11138 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11139 reloc = R_NDS32_WORD_9_PCREL_RELA;
11140 }
11141 else
11142 return FALSE;
11143
11144 /* Set all relocations. */
11145 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), reloc);
11146
11147 /* Clean relocations. */
11148 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11149 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
11150 {
11151 cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11152 checked_types[i], laddr);
11153 if (cond_irel != irelend)
11154 {
11155 if (*seq_len == 0
11156 && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
11157 {
11158 /* If the branch instruction is 2 byte, it cannot remove
11159 directly. Only convert it to nop16 and remove it after
11160 checking alignment issue. */
11161 insn16 = NDS32_NOP16;
11162 bfd_putb16 (insn16, contents + laddr);
11163 cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
11164 }
11165 else
11166 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11167 R_NDS32_NONE);
11168 }
11169 }
11170 *insn_len = 0;
11171
11172 return TRUE;
11173 }
11174
11175 /* Relax LONGJUMP6 relocation for nds32_elf_relax_section. */
11176
11177 static bfd_boolean
11178 nds32_elf_relax_longjump6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11179 Elf_Internal_Rela *internal_relocs, int *insn_len,
11180 int *seq_len, bfd_byte *contents,
11181 Elf_Internal_Sym *isymbuf,
11182 Elf_Internal_Shdr *symtab_hdr)
11183 {
11184 /* There are 5 variations for LONGJUMP6
11185 case : 2-4-4-4; 1st insn convertible, 16-bit on.
11186 bnes38 rt, ra, .L1 ; LONGJUMP6/15_PCREL/INSN16
11187 sethi ta, hi20(symbol) ; HI20/PTR
11188 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
11189 jr ta ; PTR_RES/INSN16/EMPTY
11190 .L1:
11191
11192 case : 4-4-4-4; 1st insn not convertible, 16-bit on.
11193 bne rt, ra, .L1 ; LONGJUMP6/15_PCREL/INSN16
11194 sethi ta, hi20(symbol) ; HI20/PTR
11195 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
11196 jr ta ; PTR_RES/INSN16/EMPTY
11197 .L1: */
11198
11199 enum elf_nds32_reloc_type checked_types[] =
11200 { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
11201 R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
11202
11203 int reloc_off = 0, cond_removed = 0;
11204 bfd_vma laddr;
11205 Elf_Internal_Rela *cond_irel, *em_irel, *irelend, *insn_irel;
11206 unsigned int i;
11207 bfd_signed_vma foff;
11208 uint32_t insn, re_insn = 0;
11209 uint16_t insn16, re_insn16 = 0;
11210 unsigned long reloc;
11211
11212 irelend = internal_relocs + sec->reloc_count;
11213 laddr = irel->r_offset;
11214
11215 /* Get the reloc for the address from which the register is
11216 being loaded. This reloc will tell us which function is
11217 actually being called. */
11218 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11219 R_NDS32_EMPTY, irel->r_addend);
11220
11221 if (em_irel == irelend)
11222 {
11223 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP6",
11224 (uint64_t) irel->r_offset);
11225 return FALSE;
11226 }
11227
11228 /* Get the value of the symbol referred to by the reloc. */
11229 foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr);
11230
11231 if (foff == 0
11232 || foff < -CONSERVATIVE_24BIT_S1
11233 || foff >= CONSERVATIVE_24BIT_S1)
11234 return FALSE;
11235
11236 insn = bfd_getb32 (contents + laddr);
11237 /* Check instruction size. */
11238 if (insn & 0x80000000)
11239 {
11240 *seq_len = 0;
11241 insn16 = insn >> 16;
11242 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
11243 }
11244 else
11245 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
11246
11247 /* For simplicity of coding, we are going to modify the section
11248 contents, the section relocs, and the BFD symbol table. We
11249 must tell the rest of the code not to free up this
11250 information. It would be possible to instead create a table
11251 of changes which have to be made, as is done in coff-mips.c;
11252 that would be more work, but would require less memory when
11253 the linker is run. */
11254
11255 if (N32_OP6 (re_insn) == N32_OP6_BR1
11256 && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
11257 {
11258 /* beqs label ; 15_PCREL. */
11259 bfd_putb32 (re_insn, contents + em_irel->r_offset);
11260 reloc = R_NDS32_15_PCREL_RELA;
11261 cond_removed = 1;
11262 }
11263 else if (N32_OP6 (re_insn) == N32_OP6_BR2
11264 && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
11265 {
11266 /* beqz label ; 17_PCREL. */
11267 bfd_putb32 (re_insn, contents + em_irel->r_offset);
11268 reloc = R_NDS32_17_PCREL_RELA;
11269 cond_removed = 1;
11270 }
11271 else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
11272 && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
11273 {
11274 /* Relax to one of the following 2 variations
11275
11276 case 2-4; 1st insn convertible, 16-bit on.
11277 bnes38 rt, ra, .L1 ; LONGJUMP5/9_PCREL/INSN16
11278 j label ; 25_PCREL/INSN16
11279 $1:
11280
11281 case 4-4; 1st insn not convertible
11282 bne rt, ra, .L1 ; LONGJUMP5/15_PCREL/INSN16
11283 j label ; 25_PCREL/INSN16
11284 .L1: */
11285
11286 /* Use j label as second instruction. */
11287 insn = INSN_J;
11288 reloc = R_NDS32_25_PCREL_RELA;
11289 bfd_putb32 (insn, contents + em_irel->r_offset);
11290 }
11291 else
11292 return FALSE;
11293
11294 /* Set all relocations. */
11295 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), reloc);
11296
11297 cond_irel =
11298 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11299 R_NDS32_PTR_RESOLVED, em_irel->r_offset);
11300 cond_irel->r_addend = 1;
11301
11302 /* Use INSN16 of first branch instruction to distinguish if keeping
11303 INSN16 of final instruction or not. */
11304 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11305 R_NDS32_INSN16, irel->r_offset);
11306 if (insn_irel == irelend)
11307 {
11308 /* Clean the final INSN16. */
11309 insn_irel =
11310 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11311 R_NDS32_INSN16, em_irel->r_offset);
11312 insn_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11313 R_NDS32_NONE);
11314 }
11315
11316 if (cond_removed == 1)
11317 {
11318 *insn_len = 0;
11319
11320 /* Clear relocations. */
11321 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11322
11323 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
11324 {
11325 cond_irel =
11326 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11327 checked_types[i], laddr);
11328 if (cond_irel != irelend)
11329 {
11330 if (*seq_len == 0
11331 && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
11332 {
11333 /* If the branch instruction is 2 byte, it cannot remove
11334 directly. Only convert it to nop16 and remove it after
11335 checking alignment issue. */
11336 insn16 = NDS32_NOP16;
11337 bfd_putb16 (insn16, contents + laddr);
11338 cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
11339 }
11340 else
11341 cond_irel->r_info =
11342 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
11343 }
11344 }
11345 }
11346 else
11347 {
11348 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11349 R_NDS32_LONGJUMP5);
11350 }
11351
11352 return TRUE;
11353 }
11354
11355 /* Relax LONGJUMP7 relocation for nds32_elf_relax_section. */
11356
11357 static bfd_boolean
11358 nds32_elf_relax_longjump7 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11359 Elf_Internal_Rela *internal_relocs, int *insn_len,
11360 int *seq_len, bfd_byte *contents,
11361 Elf_Internal_Sym *isymbuf,
11362 Elf_Internal_Shdr *symtab_hdr)
11363 {
11364 /* There are 2 variations for LONGJUMP5
11365 case 2-4; 1st insn convertible, 16-bit on.
11366 movi55 ta, imm11 ; LONGJUMP7/INSN16
11367 beq rt, ta, label ; 15_PCREL
11368
11369 case 4-4; 1st insn not convertible
11370 movi55 ta, imm11 ; LONGJUMP7/INSN16
11371 beq rt, ta, label ; 15_PCREL */
11372
11373 bfd_vma laddr;
11374 Elf_Internal_Rela *cond_irel, *irelend, *insn_irel;
11375 bfd_signed_vma foff;
11376 uint32_t insn, re_insn = 0;
11377 uint16_t insn16;
11378 uint32_t imm11;
11379
11380 irelend = internal_relocs + sec->reloc_count;
11381 laddr = irel->r_offset;
11382
11383 /* Get the reloc for the address from which the register is
11384 being loaded. This reloc will tell us which function is
11385 actually being called. */
11386
11387 cond_irel =
11388 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11389 R_NDS32_15_PCREL_RELA, irel->r_addend);
11390 if (cond_irel == irelend)
11391 {
11392 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP7",
11393 (uint64_t) irel->r_offset);
11394 return FALSE;
11395 }
11396
11397 /* Get the value of the symbol referred to by the reloc. */
11398 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr);
11399
11400 if (foff == 0
11401 || foff < -CONSERVATIVE_8BIT_S1
11402 || foff >= CONSERVATIVE_8BIT_S1)
11403 return FALSE;
11404
11405 /* Get the first instruction for its size. */
11406 insn = bfd_getb32 (contents + laddr);
11407 if (insn & 0x80000000)
11408 {
11409 *seq_len = 0;
11410 /* Get the immediate from movi55. */
11411 imm11 = N16_IMM5S (insn >> 16);
11412 }
11413 else
11414 {
11415 /* Get the immediate from movi. */
11416 imm11 = N32_IMM20S (insn);
11417 }
11418
11419 /* Get the branch instruction. */
11420 insn = bfd_getb32 (contents + irel->r_addend);
11421 /* Convert instruction to BR3. */
11422 if ((insn >> 14) & 0x1)
11423 re_insn = N32_BR3 (BNEC, N32_RT5 (insn), imm11, 0);
11424 else
11425 re_insn = N32_BR3 (BEQC, N32_RT5 (insn), imm11, 0);
11426
11427 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11428
11429 /* Set all relocations. */
11430 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11431 R_NDS32_WORD_9_PCREL_RELA);
11432
11433 /* Clean relocations. */
11434 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11435 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11436 R_NDS32_INSN16, irel->r_offset);
11437 if (insn_irel != irelend)
11438 {
11439 if (*seq_len == 0)
11440 {
11441 /* If the first insntruction is 16bit, convert it to nop16. */
11442 insn16 = NDS32_NOP16;
11443 bfd_putb16 (insn16, contents + laddr);
11444 insn_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
11445 }
11446 else
11447 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11448 R_NDS32_NONE);
11449 }
11450 *insn_len = 0;
11451
11452 return TRUE;
11453 }
11454
11455 /* We figure out and reassign the best gp value in nds32_elf_final_sda_base
11456 for each relax round. But the gp may changed dramatically and then cause
11457 the truncated to fit errors for the the converted gp instructions.
11458 Therefore, we must reserve the minimum but safe enough size to prevent it. */
11459
11460 static bfd_boolean
11461 nds32_elf_relax_guard (bfd_vma *access_addr, bfd_vma local_sda, asection *sec,
11462 Elf_Internal_Rela *irel, bfd_boolean *again,
11463 bfd_boolean init,
11464 struct elf_nds32_link_hash_table *table,
11465 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr)
11466
11467 {
11468 int offset_to_gp;
11469 static bfd_boolean sec_pass = FALSE;
11470 static asection *first_sec = NULL, *sym_sec;
11471 /* Record the number of instructions which may be removed. */
11472 static int count = 0, record_count;
11473 Elf_Internal_Sym *isym;
11474 struct elf_link_hash_entry *h = NULL;
11475 int indx;
11476 unsigned long r_symndx;
11477 bfd *abfd = sec->owner;
11478 static bfd_vma record_sda = 0;
11479 int sda_offset = 0;
11480
11481 /* Force doing relaxation when hyper-relax is high. */
11482 if (table->hyper_relax == 2)
11483 return TRUE;
11484
11485 /* Do not relax the load/store patterns for the first
11486 relax round. */
11487 if (init)
11488 {
11489 if (!first_sec)
11490 first_sec = sec;
11491 else if (first_sec == sec)
11492 {
11493 record_count = count;
11494 count = 0;
11495 sec_pass = TRUE;
11496 }
11497
11498 if (!sec_pass)
11499 *again = TRUE;
11500
11501 return TRUE;
11502 }
11503
11504 /* Generally, _SDA_BASE_ is fixed or smaller. But the large
11505 DATA_SEGMENT_ALIGN size in the linker script may make it
11506 get even bigger. */
11507 if (record_sda == 0)
11508 record_sda = local_sda;
11509 else if (local_sda > record_sda)
11510 sda_offset = local_sda - record_sda;
11511
11512 /* Assume the instruction will be removed in the best case. */
11513 count++;
11514
11515 /* We record the offset to gp for each symbol, and then check
11516 if it is changed dramatically after relaxing.
11517 (global symbol): elf32_nds32_hash_entry (h)->offset_to_gp
11518 (local symbol) : elf32_nds32_local_gp_offset (abfd)[r_symndx]. */
11519 r_symndx = ELF32_R_SYM (irel->r_info);
11520 if (r_symndx >= symtab_hdr->sh_info)
11521 {
11522 /* Global symbols. */
11523 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
11524 h = elf_sym_hashes (abfd)[indx];
11525 sym_sec = h->root.u.def.section;
11526 if (NDS32_GUARD_SEC_P (sym_sec->flags)
11527 || bfd_is_abs_section (sym_sec))
11528 {
11529 /* Forbid doing relaxation when hyper-relax is low. */
11530 if (table->hyper_relax == 0)
11531 return FALSE;
11532
11533 offset_to_gp = *access_addr - local_sda;
11534 if (elf32_nds32_hash_entry (h)->offset_to_gp == 0)
11535 elf32_nds32_hash_entry (h)->offset_to_gp = offset_to_gp;
11536 else if (abs (elf32_nds32_hash_entry (h)->offset_to_gp)
11537 < abs (offset_to_gp) - sda_offset)
11538 {
11539 /* This may cause the error, so we reserve the
11540 safe enough size for relaxing. */
11541 if (*access_addr >= local_sda)
11542 *access_addr += (record_count * 4);
11543 else
11544 *access_addr -= (record_count * 4);
11545 }
11546 return sec_pass;
11547 }
11548 }
11549 else
11550 {
11551 /* Local symbols. */
11552 if (!elf32_nds32_allocate_local_sym_info (abfd))
11553 return FALSE;
11554 isym = isymbuf + r_symndx;
11555
11556 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
11557 if (NDS32_GUARD_SEC_P (sym_sec->flags))
11558 {
11559 /* Forbid doing relaxation when hyper-relax is low. */
11560 if (table->hyper_relax == 0)
11561 return FALSE;
11562
11563 offset_to_gp = *access_addr - local_sda;
11564 if (elf32_nds32_local_gp_offset (abfd)[r_symndx] == 0)
11565 elf32_nds32_local_gp_offset (abfd)[r_symndx] = offset_to_gp;
11566 else if (abs (elf32_nds32_local_gp_offset (abfd)[r_symndx])
11567 < abs (offset_to_gp) - sda_offset)
11568 {
11569 /* This may cause the error, so we reserve the
11570 safe enough size for relaxing. */
11571 if (*access_addr >= local_sda)
11572 *access_addr += (record_count * 4);
11573 else
11574 *access_addr -= (record_count * 4);
11575 }
11576 return sec_pass;
11577 }
11578 }
11579
11580 return TRUE;
11581 }
11582
11583 #define GET_LOADSTORE_RANGE(addend) (((addend) >> 8) & 0x3f)
11584
11585 /* Relax LOADSTORE relocation for nds32_elf_relax_section. */
11586
11587 static bfd_boolean
11588 nds32_elf_relax_loadstore (struct bfd_link_info *link_info, bfd *abfd,
11589 asection *sec, Elf_Internal_Rela *irel,
11590 Elf_Internal_Rela *internal_relocs, int *insn_len,
11591 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11592 Elf_Internal_Shdr *symtab_hdr, int load_store_relax,
11593 struct elf_nds32_link_hash_table *table)
11594 {
11595 int eliminate_sethi = 0, range_type;
11596 unsigned int i;
11597 bfd_vma local_sda, laddr;
11598 int seq_len; /* Original length of instruction sequence. */
11599 uint32_t insn;
11600 Elf_Internal_Rela *hi_irelfn = NULL, *irelend;
11601 bfd_vma access_addr = 0;
11602 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
11603 struct elf_link_hash_entry *h = NULL;
11604 int indx;
11605 enum elf_nds32_reloc_type checked_types[] =
11606 { R_NDS32_HI20_RELA, R_NDS32_GOT_HI20,
11607 R_NDS32_GOTPC_HI20, R_NDS32_GOTOFF_HI20,
11608 R_NDS32_PLTREL_HI20, R_NDS32_PLT_GOTREL_HI20,
11609 R_NDS32_TLS_LE_HI20
11610 };
11611
11612 irelend = internal_relocs + sec->reloc_count;
11613 seq_len = GET_SEQ_LEN (irel->r_addend);
11614 laddr = irel->r_offset;
11615 *insn_len = seq_len;
11616
11617 /* Get the high part relocation. */
11618 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
11619 {
11620 hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11621 checked_types[i], laddr);
11622 if (hi_irelfn != irelend)
11623 break;
11624 }
11625
11626 if (hi_irelfn == irelend)
11627 {
11628 /* Not R_NDS32_HI20_RELA. */
11629 if (i != 0)
11630 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LOADSTORE",
11631 (uint64_t) irel->r_offset);
11632 return FALSE;
11633 }
11634
11635 range_type = GET_LOADSTORE_RANGE (irel->r_addend);
11636 nds32_elf_final_sda_base (sec->output_section->owner,
11637 link_info, &local_sda, FALSE);
11638
11639 switch (ELF32_R_TYPE (hi_irelfn->r_info))
11640 {
11641 case R_NDS32_HI20_RELA:
11642 insn = bfd_getb32 (contents + laddr);
11643 access_addr =
11644 calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
11645
11646 if (ELF32_R_SYM (hi_irelfn->r_info) >= symtab_hdr->sh_info)
11647 {
11648 indx = ELF32_R_SYM (hi_irelfn->r_info) - symtab_hdr->sh_info;
11649 h = elf_sym_hashes (abfd)[indx];
11650 }
11651
11652 /* Try movi. */
11653 if (range_type == NDS32_LOADSTORE_IMM
11654 && access_addr < CONSERVATIVE_20BIT
11655 && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
11656 {
11657 eliminate_sethi = 1;
11658 break;
11659 }
11660
11661 if (h && strcmp (h->root.root.string, FP_BASE_NAME) == 0)
11662 {
11663 eliminate_sethi = 1;
11664 break;
11665 }
11666 else if (!nds32_elf_relax_guard (&access_addr, local_sda, sec, hi_irelfn,
11667 NULL, FALSE, table, isymbuf, symtab_hdr))
11668 return FALSE;
11669
11670 if (!load_store_relax)
11671 return FALSE;
11672
11673 /* Case for set gp register. */
11674 if (N32_RT5 (insn) == REG_GP)
11675 return FALSE;
11676
11677 if (range_type == NDS32_LOADSTORE_FLOAT_S
11678 || range_type == NDS32_LOADSTORE_FLOAT_D)
11679 {
11680 range_l = sdata_range[0][0];
11681 range_h = sdata_range[0][1];
11682 }
11683 else
11684 {
11685 range_l = sdata_range[1][0];
11686 range_h = sdata_range[1][1];
11687 }
11688 break;
11689
11690 default:
11691 return FALSE;
11692 }
11693
11694 /* Delete sethi instruction. */
11695 if (eliminate_sethi == 1
11696 || (local_sda <= access_addr && (access_addr - local_sda) < range_h)
11697 || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
11698 {
11699 hi_irelfn->r_info =
11700 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
11701 irel->r_info =
11702 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11703 *insn_len = 0;
11704 return TRUE;
11705 }
11706
11707 return FALSE;
11708 }
11709
11710 /* Relax LO12 relocation for nds32_elf_relax_section. */
11711
11712 static void
11713 nds32_elf_relax_lo12 (struct bfd_link_info *link_info, bfd *abfd,
11714 asection *sec, Elf_Internal_Rela *irel,
11715 Elf_Internal_Rela *internal_relocs, bfd_byte *contents,
11716 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr,
11717 struct elf_nds32_link_hash_table *table)
11718 {
11719 uint32_t insn;
11720 bfd_vma local_sda, laddr;
11721 unsigned long reloc;
11722 bfd_vma access_addr;
11723 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
11724 Elf_Internal_Rela *irelfn = NULL, *irelend;
11725 struct elf_link_hash_entry *h = NULL;
11726 int indx;
11727
11728 /* For SDA base relative relaxation. */
11729 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11730 &local_sda, FALSE);
11731
11732 irelend = internal_relocs + sec->reloc_count;
11733 laddr = irel->r_offset;
11734 insn = bfd_getb32 (contents + laddr);
11735
11736 if (!is_sda_access_insn (insn) && N32_OP6 (insn) != N32_OP6_ORI)
11737 return;
11738
11739 access_addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11740
11741 if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
11742 {
11743 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
11744 h = elf_sym_hashes (abfd)[indx];
11745 }
11746
11747 /* Try movi. */
11748 if (N32_OP6 (insn) == N32_OP6_ORI && access_addr < CONSERVATIVE_20BIT
11749 && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
11750 {
11751 reloc = R_NDS32_20_RELA;
11752 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11753 insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
11754 bfd_putb32 (insn, contents + laddr);
11755 }
11756 else
11757 {
11758 if (h && strcmp (h->root.root.string, FP_BASE_NAME) == 0)
11759 {
11760 /* Fall through. */
11761 }
11762 else if (!nds32_elf_relax_guard (&access_addr, local_sda, sec, irel, NULL,
11763 FALSE, table, isymbuf, symtab_hdr))
11764 return;
11765
11766 range_l = sdata_range[1][0];
11767 range_h = sdata_range[1][1];
11768 switch (ELF32_R_TYPE (irel->r_info))
11769 {
11770 case R_NDS32_LO12S0_RELA:
11771 reloc = R_NDS32_SDA19S0_RELA;
11772 break;
11773 case R_NDS32_LO12S1_RELA:
11774 reloc = R_NDS32_SDA18S1_RELA;
11775 break;
11776 case R_NDS32_LO12S2_RELA:
11777 reloc = R_NDS32_SDA17S2_RELA;
11778 break;
11779 case R_NDS32_LO12S2_DP_RELA:
11780 range_l = sdata_range[0][0];
11781 range_h = sdata_range[0][1];
11782 reloc = R_NDS32_SDA12S2_DP_RELA;
11783 break;
11784 case R_NDS32_LO12S2_SP_RELA:
11785 range_l = sdata_range[0][0];
11786 range_h = sdata_range[0][1];
11787 reloc = R_NDS32_SDA12S2_SP_RELA;
11788 break;
11789 default:
11790 return;
11791 }
11792
11793 /* There are range_h and range_l because linker has to promise
11794 all sections move cross one page together. */
11795 if ((local_sda <= access_addr && (access_addr - local_sda) < range_h)
11796 || (local_sda > access_addr && (local_sda - access_addr) <= range_l)
11797 || (h && strcmp (h->root.root.string, FP_BASE_NAME) == 0))
11798 {
11799 if (N32_OP6 (insn) == N32_OP6_ORI && N32_RT5 (insn) == REG_GP)
11800 {
11801 /* Maybe we should add R_NDS32_INSN16 reloc type here
11802 or manually do some optimization. sethi can't be
11803 eliminated when updating $gp so the relative ori
11804 needs to be preserved. */
11805 return;
11806 }
11807 if (!turn_insn_to_sda_access (insn, ELF32_R_TYPE (irel->r_info),
11808 &insn))
11809 return;
11810 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11811 bfd_putb32 (insn, contents + laddr);
11812
11813 irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11814 R_NDS32_INSN16);
11815 /* SDA17 must keep INSN16 for converting fp_as_gp. */
11816 if (irelfn != irelend && reloc != R_NDS32_SDA17S2_RELA)
11817 irelfn->r_info =
11818 ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_NDS32_NONE);
11819
11820 }
11821 }
11822 return;
11823 }
11824
11825 /* Relax PTR relocation for nds32_elf_relax_section. */
11826
11827 static bfd_boolean
11828 nds32_elf_relax_ptr (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11829 Elf_Internal_Rela *internal_relocs, int *insn_len,
11830 int *seq_len, bfd_byte *contents)
11831 {
11832 Elf_Internal_Rela *ptr_irel, *irelend, *count_irel, *re_irel;
11833
11834 irelend = internal_relocs + sec->reloc_count;
11835
11836 re_irel =
11837 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11838 R_NDS32_PTR_RESOLVED, irel->r_addend);
11839
11840 if (re_irel == irelend)
11841 {
11842 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_PTR",
11843 (uint64_t) irel->r_offset);
11844 return FALSE;
11845 }
11846
11847 if (re_irel->r_addend != 1)
11848 return FALSE;
11849
11850 /* Pointed target is relaxed and no longer needs this void *,
11851 change the type to NONE. */
11852 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11853
11854 /* Find PTR_COUNT to decide remove it or not. If PTR_COUNT does
11855 not exist, it means only count 1 and remove it directly. */
11856 /* TODO: I hope we can obsolate R_NDS32_COUNT in the future. */
11857 count_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11858 R_NDS32_PTR_COUNT);
11859 ptr_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11860 R_NDS32_PTR);
11861 if (count_irel != irelend)
11862 {
11863 if (--count_irel->r_addend > 0)
11864 return FALSE;
11865 }
11866
11867 if (ptr_irel != irelend)
11868 return FALSE;
11869
11870 /* If the PTR_COUNT is already 0, remove current instruction. */
11871 *seq_len = nds32_elf_insn_size (abfd, contents, irel->r_offset);
11872 *insn_len = 0;
11873 return TRUE;
11874 }
11875
11876 /* Relax LWC relocation for nds32_elf_relax_section. */
11877
11878 static void
11879 nds32_elf_relax_flsi (struct bfd_link_info *link_info, bfd *abfd,
11880 asection *sec, Elf_Internal_Rela *irel,
11881 Elf_Internal_Rela *internal_relocs,
11882 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11883 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11884 {
11885 /* Pattern:
11886 sethi ra, hi20(symbol) ; HI20/LOADSTORE
11887 ori ra, ra, lo12(symbol) ; LO12S0/PTR/PTR/.../INSN16
11888 flsi fsa, [ra + offset1] ; LSI/PTR_RESOLVED/INSN16
11889 flsi fsb, [ra + offset2] ; LSI/PTR_RESOLVED/INSN16
11890 ... */
11891
11892 uint32_t insn;
11893 bfd_vma local_sda, laddr;
11894 unsigned long reloc;
11895 bfd_vma access_addr, flsi_offset;
11896 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
11897 Elf_Internal_Rela *irelend, *re_irel;
11898 unsigned int opcode;
11899
11900 irelend = internal_relocs + sec->reloc_count;
11901 laddr = irel->r_offset;
11902 insn = bfd_getb32 (contents + laddr);
11903
11904 if ((insn & 0x80000000) || !is_sda_access_insn (insn))
11905 return;
11906
11907 /* Can not do relaxation for bi format. */
11908 if ((insn & 0x1000))
11909 return;
11910
11911 /* Only deal with flsi, fssi, fldi, fsdi, so far. */
11912 opcode = N32_OP6 (insn);
11913 if ((opcode == N32_OP6_LWC) || (opcode == N32_OP6_SWC))
11914 reloc = R_NDS32_SDA12S2_SP_RELA;
11915 else if ((opcode == N32_OP6_LDC) || (opcode == N32_OP6_SDC))
11916 reloc = R_NDS32_SDA12S2_DP_RELA;
11917 else
11918 return;
11919
11920 re_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11921 R_NDS32_PTR_RESOLVED);
11922 if (re_irel == irelend)
11923 {
11924 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LSI",
11925 (uint64_t) irel->r_offset);
11926 return;
11927 }
11928
11929 /* For SDA base relative relaxation. */
11930 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11931 &local_sda, FALSE);
11932 access_addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11933 flsi_offset = (insn & 0xfff) << 2;
11934 access_addr += flsi_offset;
11935 range_l = sdata_range[0][0];
11936 range_h = sdata_range[0][1];
11937
11938 if ((local_sda <= access_addr && (access_addr - local_sda) < range_h)
11939 || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
11940 {
11941 /* Turn flsi instruction into sda access format. */
11942 insn = (insn & 0x7ff07000) | (REG_GP << 15);
11943
11944 /* Add relocation type to flsi. */
11945 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11946 irel->r_addend += flsi_offset;
11947 bfd_putb32 (insn, contents + re_irel->r_offset);
11948
11949 re_irel->r_addend |= 1;
11950 *again = TRUE;
11951 }
11952 }
11953
11954 static bfd_boolean
11955 nds32_relax_adjust_label (bfd *abfd, asection *sec,
11956 Elf_Internal_Rela *internal_relocs,
11957 bfd_byte *contents,
11958 nds32_elf_blank_t **relax_blank_list,
11959 int optimize, int opt_size)
11960 {
11961 /* This code block is used to adjust 4-byte alignment by relax a pair
11962 of instruction a time.
11963
11964 It recognizes three types of relocations.
11965 1. R_NDS32_LABEL - a alignment.
11966 2. R_NDS32_INSN16 - relax a 32-bit instruction to 16-bit.
11967 3. is_16bit_NOP () - remove a 16-bit instruction. */
11968
11969 /* TODO: It seems currently implementation only support 4-byte alignment.
11970 We should handle any-alignment. */
11971
11972 Elf_Internal_Rela *insn_rel = NULL, *label_rel = NULL, *irel;
11973 Elf_Internal_Rela *tmp_rel, *tmp2_rel = NULL;
11974 Elf_Internal_Rela rel_temp;
11975 Elf_Internal_Rela *irelend;
11976 bfd_vma address;
11977 uint16_t insn16;
11978
11979 /* Checking for branch relaxation relies on the relocations to
11980 be sorted on 'r_offset'. This is not guaranteed so we must sort. */
11981 nds32_insertion_sort (internal_relocs, sec->reloc_count,
11982 sizeof (Elf_Internal_Rela), compar_reloc);
11983
11984 irelend = internal_relocs + sec->reloc_count;
11985
11986 /* Force R_NDS32_LABEL before R_NDS32_INSN16. */
11987 /* FIXME: Can we generate the right order in assembler?
11988 So we don't have to swapping them here. */
11989
11990 for (label_rel = internal_relocs, insn_rel = internal_relocs;
11991 label_rel < irelend; label_rel++)
11992 {
11993 if (ELF32_R_TYPE (label_rel->r_info) != R_NDS32_LABEL)
11994 continue;
11995
11996 /* Find the first reloc has the same offset with label_rel. */
11997 while (insn_rel < irelend && insn_rel->r_offset < label_rel->r_offset)
11998 insn_rel++;
11999
12000 for (;insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset;
12001 insn_rel++)
12002 /* Check if there were R_NDS32_INSN16 and R_NDS32_LABEL at the same
12003 address. */
12004 if (ELF32_R_TYPE (insn_rel->r_info) == R_NDS32_INSN16)
12005 break;
12006
12007 if (insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset
12008 && insn_rel < label_rel)
12009 {
12010 /* Swap the two reloc if the R_NDS32_INSN16 is
12011 before R_NDS32_LABEL. */
12012 memcpy (&rel_temp, insn_rel, sizeof (Elf_Internal_Rela));
12013 memcpy (insn_rel, label_rel, sizeof (Elf_Internal_Rela));
12014 memcpy (label_rel, &rel_temp, sizeof (Elf_Internal_Rela));
12015 }
12016 }
12017
12018 label_rel = NULL;
12019 insn_rel = NULL;
12020 /* If there were a sequence of R_NDS32_LABEL end up with .align 2
12021 or higher, remove other R_NDS32_LABEL with lower alignment.
12022 If an R_NDS32_INSN16 in between R_NDS32_LABELs must be converted,
12023 then the R_NDS32_LABEL sequence is broke. */
12024 for (tmp_rel = internal_relocs; tmp_rel < irelend; tmp_rel++)
12025 {
12026 if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_LABEL)
12027 {
12028 if (label_rel == NULL)
12029 {
12030 if (tmp_rel->r_addend < 2)
12031 label_rel = tmp_rel;
12032 continue;
12033 }
12034 else if (tmp_rel->r_addend > 1)
12035 {
12036 /* Remove all LABEL relocation from label_rel to tmp_rel
12037 including relocations with same offset as tmp_rel. */
12038 for (tmp2_rel = label_rel; tmp2_rel < tmp_rel; tmp2_rel++)
12039 {
12040 if (tmp2_rel->r_offset == tmp_rel->r_offset)
12041 break;
12042
12043 if (ELF32_R_TYPE (tmp2_rel->r_info) == R_NDS32_LABEL
12044 && tmp2_rel->r_addend < 2)
12045 tmp2_rel->r_info =
12046 ELF32_R_INFO (ELF32_R_SYM (tmp2_rel->r_info),
12047 R_NDS32_NONE);
12048 }
12049 label_rel = NULL;
12050 }
12051 }
12052 else if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16 && label_rel)
12053 {
12054 /* A new INSN16 which can be converted, so clear label_rel. */
12055 if (is_convert_32_to_16 (abfd, sec, tmp_rel, internal_relocs,
12056 irelend, &insn16)
12057 || is_16bit_NOP (abfd, sec, tmp_rel))
12058 label_rel = NULL;
12059 }
12060 }
12061
12062 label_rel = NULL;
12063 insn_rel = NULL;
12064 /* Optimized for speed and nothing has not been relaxed.
12065 It's time to align labels.
12066 We may convert a 16-bit instruction right before a label to
12067 32-bit, in order to align the label if necessary
12068 all reloc entries has been sorted by r_offset. */
12069 for (irel = internal_relocs;
12070 irel < irelend && irel->r_offset < sec->size; irel++)
12071 {
12072 if (ELF32_R_TYPE (irel->r_info) != R_NDS32_INSN16
12073 && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL)
12074 continue;
12075
12076 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_INSN16)
12077 {
12078 /* A new INSN16 found, resize the old one. */
12079 if (is_convert_32_to_16
12080 (abfd, sec, irel, internal_relocs, irelend, &insn16)
12081 || is_16bit_NOP (abfd, sec, irel))
12082 {
12083 if (insn_rel)
12084 {
12085 /* Previous INSN16 reloc exists, reduce its
12086 size to 16-bit. */
12087 if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
12088 irelend, &insn16))
12089 {
12090 nds32_elf_write_16 (abfd, contents, insn_rel,
12091 internal_relocs, irelend, insn16);
12092
12093 if (!insert_nds32_elf_blank_recalc_total
12094 (relax_blank_list, insn_rel->r_offset + 2, 2))
12095 return FALSE;
12096 }
12097 else if (is_16bit_NOP (abfd, sec, insn_rel))
12098 {
12099 if (!insert_nds32_elf_blank_recalc_total
12100 (relax_blank_list, insn_rel->r_offset, 2))
12101 return FALSE;
12102 }
12103 insn_rel->r_info =
12104 ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info), R_NDS32_NONE);
12105 }
12106 /* Save the new one for later use. */
12107 insn_rel = irel;
12108 }
12109 else
12110 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
12111 R_NDS32_NONE);
12112 }
12113 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL)
12114 {
12115 /* Search for label. */
12116 int force_relax = 0;
12117
12118 /* Label on 16-bit instruction or optimization
12119 needless, just reset this reloc. */
12120 insn16 = bfd_getb16 (contents + irel->r_offset);
12121 if ((irel->r_addend & 0x1f) < 2 && (!optimize || (insn16 & 0x8000)))
12122 {
12123 irel->r_info =
12124 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
12125 continue;
12126 }
12127
12128 address =
12129 irel->r_offset - get_nds32_elf_blank_total (relax_blank_list,
12130 irel->r_offset, 1);
12131
12132 if (!insn_rel)
12133 {
12134 /* Check if there is case which can not be aligned. */
12135 if (irel->r_addend == 2 && address & 0x2)
12136 return FALSE;
12137 continue;
12138 }
12139
12140 /* Try to align this label. */
12141
12142 if ((irel->r_addend & 0x1f) < 2)
12143 {
12144 /* Check if there is a INSN16 at the same address.
12145 Label_rel always seats before insn_rel after
12146 our sort. */
12147
12148 /* Search for INSN16 at LABEL location. If INSN16 is at
12149 same location and this LABEL alignment is lower than 2,
12150 the INSN16 can be converted to 2-byte. */
12151 for (tmp_rel = irel;
12152 tmp_rel < irelend && tmp_rel->r_offset == irel->r_offset;
12153 tmp_rel++)
12154 {
12155 if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16
12156 && (is_convert_32_to_16
12157 (abfd, sec, tmp_rel, internal_relocs,
12158 irelend, &insn16)
12159 || is_16bit_NOP (abfd, sec, tmp_rel)))
12160 {
12161 force_relax = 1;
12162 break;
12163 }
12164 }
12165 }
12166
12167 if (force_relax || irel->r_addend == 1 || address & 0x2)
12168 {
12169 /* Label not aligned. */
12170 /* Previous reloc exists, reduce its size to 16-bit. */
12171 if (is_convert_32_to_16 (abfd, sec, insn_rel,
12172 internal_relocs, irelend, &insn16))
12173 {
12174 nds32_elf_write_16 (abfd, contents, insn_rel,
12175 internal_relocs, irelend, insn16);
12176
12177 if (!insert_nds32_elf_blank_recalc_total
12178 (relax_blank_list, insn_rel->r_offset + 2, 2))
12179 return FALSE;
12180 }
12181 else if (is_16bit_NOP (abfd, sec, insn_rel))
12182 {
12183 if (!insert_nds32_elf_blank_recalc_total
12184 (relax_blank_list, insn_rel->r_offset, 2))
12185 return FALSE;
12186 }
12187
12188 }
12189 /* INSN16 reloc is used. */
12190 insn_rel = NULL;
12191 }
12192 }
12193
12194 address =
12195 sec->size - get_nds32_elf_blank_total (relax_blank_list, sec->size, 0);
12196 if (insn_rel && (address & 0x2 || opt_size))
12197 {
12198 if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
12199 irelend, &insn16))
12200 {
12201 nds32_elf_write_16 (abfd, contents, insn_rel, internal_relocs,
12202 irelend, insn16);
12203 if (!insert_nds32_elf_blank_recalc_total
12204 (relax_blank_list, insn_rel->r_offset + 2, 2))
12205 return FALSE;
12206 insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
12207 R_NDS32_NONE);
12208 }
12209 else if (is_16bit_NOP (abfd, sec, insn_rel))
12210 {
12211 if (!insert_nds32_elf_blank_recalc_total
12212 (relax_blank_list, insn_rel->r_offset, 2))
12213 return FALSE;
12214 insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
12215 R_NDS32_NONE);
12216 }
12217 }
12218 insn_rel = NULL;
12219 return TRUE;
12220 }
12221
12222 static bfd_boolean
12223 nds32_elf_relax_section (bfd *abfd, asection *sec,
12224 struct bfd_link_info *link_info, bfd_boolean *again)
12225 {
12226 nds32_elf_blank_t *relax_blank_list = NULL;
12227 Elf_Internal_Shdr *symtab_hdr;
12228 Elf_Internal_Rela *internal_relocs;
12229 Elf_Internal_Rela *irel;
12230 Elf_Internal_Rela *irelend;
12231 Elf_Internal_Sym *isymbuf = NULL;
12232 bfd_byte *contents = NULL;
12233 bfd_boolean result = TRUE;
12234 int optimize = 0;
12235 int opt_size = 0;
12236 uint32_t insn;
12237 uint16_t insn16;
12238
12239 /* Target dependnet option. */
12240 struct elf_nds32_link_hash_table *table;
12241 int load_store_relax;
12242
12243 relax_blank_list = NULL;
12244
12245 *again = FALSE;
12246
12247 /* Nothing to do for
12248 * relocatable link or
12249 * non-relocatable section or
12250 * non-code section or
12251 * empty content or
12252 * no reloc entry. */
12253 if (bfd_link_relocatable (link_info)
12254 || (sec->flags & SEC_RELOC) == 0
12255 || (sec->flags & SEC_EXCLUDE) != 0
12256 || (sec->flags & SEC_CODE) == 0
12257 || sec->size == 0
12258 || sec->reloc_count == 0)
12259 return TRUE;
12260
12261 /* 09.12.11 Workaround. */
12262 /* We have to adjust align for R_NDS32_LABEL if needed.
12263 The adjust approach only can fix 2-byte align once. */
12264 if (sec->alignment_power > 2)
12265 return TRUE;
12266
12267 /* Do TLS model conversion once at first. */
12268 nds32_elf_unify_tls_model (abfd, sec, contents, link_info);
12269
12270 /* The optimization type to do. */
12271
12272 table = nds32_elf_hash_table (link_info);
12273
12274 /* Save the first section for abs symbol relaxation.
12275 This is used for checking gp relaxation in the
12276 nds32_elf_relax_loadstore and nds32_elf_relax_lo12. */
12277 nds32_elf_relax_guard (NULL, 0, sec, NULL, again, TRUE,
12278 table, NULL, NULL);
12279
12280 /* The begining of general relaxation. */
12281
12282 if (is_SDA_BASE_set == 0)
12283 {
12284 bfd_vma gp;
12285 is_SDA_BASE_set = 1;
12286 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
12287 &gp, FALSE);
12288 relax_range_measurement (abfd);
12289 }
12290
12291 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12292 /* Relocations MUST be kept in memory, because relaxation adjust them. */
12293 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
12294 TRUE /* keep_memory */);
12295 if (internal_relocs == NULL)
12296 goto error_return;
12297
12298 irelend = internal_relocs + sec->reloc_count;
12299 irel = find_relocs_at_address (internal_relocs, internal_relocs,
12300 irelend, R_NDS32_RELAX_ENTRY);
12301
12302 if (irel == irelend)
12303 return TRUE;
12304
12305 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
12306 {
12307 if (irel->r_addend & R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG)
12308 return TRUE;
12309
12310 if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FLAG)
12311 optimize = 1;
12312
12313 if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FOR_SPACE_FLAG)
12314 opt_size = 1;
12315 }
12316
12317 load_store_relax = table->load_store_relax;
12318
12319 /* Get symbol table and section content. */
12320 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12321 || !nds32_get_local_syms (abfd, sec, &isymbuf))
12322 goto error_return;
12323
12324 /* Do relax loop only when finalize is not done.
12325 Take care of relaxable relocs except INSN16. */
12326 for (irel = internal_relocs; irel < irelend; irel++)
12327 {
12328 int seq_len; /* Original length of instruction sequence. */
12329 int insn_len = 0; /* Final length of instruction sequence. */
12330 bfd_boolean removed;
12331
12332 insn = 0;
12333 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
12334 && (irel->r_addend & 0x1f) >= 2)
12335 optimize = 1;
12336
12337 /* Relocation Types
12338 R_NDS32_LONGCALL1 53
12339 R_NDS32_LONGCALL2 54
12340 R_NDS32_LONGCALL3 55
12341 R_NDS32_LONGJUMP1 56
12342 R_NDS32_LONGJUMP2 57
12343 R_NDS32_LONGJUMP3 58
12344 R_NDS32_LOADSTORE 59 */
12345 if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL1
12346 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LOADSTORE)
12347 seq_len = GET_SEQ_LEN (irel->r_addend);
12348
12349 /* Relocation Types
12350 R_NDS32_LONGCALL4 107
12351 R_NDS32_LONGCALL5 108
12352 R_NDS32_LONGCALL6 109
12353 R_NDS32_LONGJUMP4 110
12354 R_NDS32_LONGJUMP5 111
12355 R_NDS32_LONGJUMP6 112
12356 R_NDS32_LONGJUMP7 113 */
12357 else if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL4
12358 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LONGJUMP7)
12359 seq_len = 4;
12360
12361 /* Relocation Types
12362 R_NDS32_LO12S0_RELA 30
12363 R_NDS32_LO12S1_RELA 29
12364 R_NDS32_LO12S2_RELA 28
12365 R_NDS32_LO12S2_SP_RELA 71
12366 R_NDS32_LO12S2_DP_RELA 70
12367 R_NDS32_GOT_LO12 46
12368 R_NDS32_GOTOFF_LO12 50
12369 R_NDS32_PLTREL_LO12 65
12370 R_NDS32_PLT_GOTREL_LO12 67
12371 R_NDS32_17IFC_PCREL_RELA 96
12372 R_NDS32_GOT_SUFF 193
12373 R_NDS32_GOTOFF_SUFF 194
12374 R_NDS32_PLT_GOT_SUFF 195
12375 R_NDS32_MULCALL_SUFF 196
12376 R_NDS32_PTR 197 */
12377 else if ((ELF32_R_TYPE (irel->r_info) <= R_NDS32_LO12S0_RELA
12378 && ELF32_R_TYPE (irel->r_info) >= R_NDS32_LO12S2_RELA)
12379 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_SP_RELA
12380 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_DP_RELA
12381 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12
12382 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12
12383 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12
12384 || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLTREL_LO12
12385 || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12
12386 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_GOT_SUFF
12387 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_PTR)
12388 || ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12389 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LO12
12390 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_ADD
12391 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LS
12392 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LSI)
12393 seq_len = 0;
12394 else
12395 continue;
12396
12397 insn_len = seq_len;
12398 removed = FALSE;
12399
12400 switch (ELF32_R_TYPE (irel->r_info))
12401 {
12402 case R_NDS32_LONGCALL1:
12403 removed = nds32_elf_relax_longcall1 (abfd, sec, irel, internal_relocs,
12404 &insn_len, contents, isymbuf,
12405 symtab_hdr);
12406 break;
12407 case R_NDS32_LONGCALL2:
12408 removed = nds32_elf_relax_longcall2 (abfd, sec, irel, internal_relocs,
12409 &insn_len, contents, isymbuf,
12410 symtab_hdr);
12411 break;
12412 case R_NDS32_LONGCALL3:
12413 removed = nds32_elf_relax_longcall3 (abfd, sec, irel, internal_relocs,
12414 &insn_len, contents, isymbuf,
12415 symtab_hdr);
12416 break;
12417 case R_NDS32_LONGJUMP1:
12418 removed = nds32_elf_relax_longjump1 (abfd, sec, irel, internal_relocs,
12419 &insn_len, contents, isymbuf,
12420 symtab_hdr);
12421 break;
12422 case R_NDS32_LONGJUMP2:
12423 removed = nds32_elf_relax_longjump2 (abfd, sec, irel, internal_relocs,
12424 &insn_len, contents, isymbuf,
12425 symtab_hdr);
12426 break;
12427 case R_NDS32_LONGJUMP3:
12428 removed = nds32_elf_relax_longjump3 (abfd, sec, irel, internal_relocs,
12429 &insn_len, contents, isymbuf,
12430 symtab_hdr);
12431 break;
12432 case R_NDS32_LONGCALL4:
12433 removed = nds32_elf_relax_longcall4 (abfd, sec, irel, internal_relocs,
12434 &insn_len, contents, isymbuf,
12435 symtab_hdr);
12436 break;
12437 case R_NDS32_LONGCALL5:
12438 removed = nds32_elf_relax_longcall5 (abfd, sec, irel, internal_relocs,
12439 &insn_len, contents, isymbuf,
12440 symtab_hdr);
12441 break;
12442 case R_NDS32_LONGCALL6:
12443 removed = nds32_elf_relax_longcall6 (abfd, sec, irel, internal_relocs,
12444 &insn_len, contents, isymbuf,
12445 symtab_hdr);
12446 break;
12447 case R_NDS32_LONGJUMP4:
12448 removed = nds32_elf_relax_longjump4 (abfd, sec, irel, internal_relocs,
12449 &insn_len, contents, isymbuf,
12450 symtab_hdr);
12451 break;
12452 case R_NDS32_LONGJUMP5:
12453 removed = nds32_elf_relax_longjump5 (abfd, sec, irel, internal_relocs,
12454 &insn_len, &seq_len, contents,
12455 isymbuf, symtab_hdr);
12456 break;
12457 case R_NDS32_LONGJUMP6:
12458 removed = nds32_elf_relax_longjump6 (abfd, sec, irel, internal_relocs,
12459 &insn_len, &seq_len, contents,
12460 isymbuf, symtab_hdr);
12461 break;
12462 case R_NDS32_LONGJUMP7:
12463 removed = nds32_elf_relax_longjump7 (abfd, sec, irel, internal_relocs,
12464 &insn_len, &seq_len, contents,
12465 isymbuf, symtab_hdr);
12466 break;
12467 case R_NDS32_LOADSTORE:
12468 removed = nds32_elf_relax_loadstore (link_info, abfd, sec, irel,
12469 internal_relocs, &insn_len,
12470 contents, isymbuf, symtab_hdr,
12471 load_store_relax, table);
12472 break;
12473 case R_NDS32_LO12S0_RELA:
12474 case R_NDS32_LO12S1_RELA:
12475 case R_NDS32_LO12S2_RELA:
12476 case R_NDS32_LO12S2_DP_RELA:
12477 case R_NDS32_LO12S2_SP_RELA:
12478 /* Relax for low part. */
12479 nds32_elf_relax_lo12 (link_info, abfd, sec, irel, internal_relocs,
12480 contents, isymbuf, symtab_hdr, table);
12481
12482 /* It is impossible to delete blank, so just continue. */
12483 continue;
12484 case R_NDS32_PTR:
12485 removed = nds32_elf_relax_ptr (abfd, sec, irel, internal_relocs,
12486 &insn_len, &seq_len, contents);
12487 break;
12488 case R_NDS32_LSI:
12489 nds32_elf_relax_flsi (link_info, abfd, sec, irel, internal_relocs,
12490 contents, isymbuf, symtab_hdr, again);
12491 continue;
12492 case R_NDS32_GOT_LO12:
12493 case R_NDS32_GOTOFF_LO12:
12494 case R_NDS32_PLTREL_LO12:
12495 case R_NDS32_PLT_GOTREL_LO12:
12496 case R_NDS32_GOTPC_LO12:
12497 case R_NDS32_TLS_LE_LO12:
12498 case R_NDS32_TLS_LE_ADD:
12499 case R_NDS32_TLS_LE_LS:
12500 case R_NDS32_PLT_GOT_SUFF:
12501 case R_NDS32_GOT_SUFF:
12502 case R_NDS32_GOTOFF_SUFF:
12503 continue;
12504 default:
12505 continue;
12506 }
12507
12508 if (removed && seq_len - insn_len > 0)
12509 {
12510 if (!insert_nds32_elf_blank
12511 (&relax_blank_list, irel->r_offset + insn_len,
12512 seq_len - insn_len))
12513 goto error_return;
12514 *again = TRUE;
12515 }
12516 }
12517
12518 calc_nds32_blank_total (relax_blank_list);
12519
12520 if (table->relax_fp_as_gp)
12521 {
12522 if (!nds32_relax_fp_as_gp (link_info, abfd, sec, internal_relocs,
12523 irelend, isymbuf))
12524 goto error_return;
12525
12526 if (!*again)
12527 {
12528 if (!nds32_fag_remove_unused_fpbase (abfd, sec, internal_relocs,
12529 irelend))
12530 goto error_return;
12531 }
12532 }
12533
12534 if (!*again)
12535 {
12536 if (!nds32_relax_adjust_label (abfd, sec, internal_relocs, contents,
12537 &relax_blank_list, optimize, opt_size))
12538 goto error_return;
12539 }
12540
12541 /* It doesn't matter optimize_for_space_no_align anymore.
12542 If object file is assembled with flag '-Os',
12543 the we don't adjust jump-destination on 4-byte boundary. */
12544
12545 if (relax_blank_list)
12546 {
12547 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12548 relax_blank_list = NULL;
12549 }
12550
12551 if (!*again)
12552 {
12553 /* Closing the section, so we don't relax it anymore. */
12554 bfd_vma sec_size_align;
12555 Elf_Internal_Rela *tmp_rel;
12556
12557 /* Pad to alignment boundary. Only handle current section alignment. */
12558 sec_size_align = (sec->size + (~((-1U) << sec->alignment_power)))
12559 & ((-1U) << sec->alignment_power);
12560 if ((sec_size_align - sec->size) & 0x2)
12561 {
12562 insn16 = NDS32_NOP16;
12563 bfd_putb16 (insn16, contents + sec->size);
12564 sec->size += 2;
12565 }
12566
12567 while (sec_size_align != sec->size)
12568 {
12569 insn = NDS32_NOP32;
12570 bfd_putb32 (insn, contents + sec->size);
12571 sec->size += 4;
12572 }
12573
12574 tmp_rel = find_relocs_at_address (internal_relocs, internal_relocs,
12575 irelend, R_NDS32_RELAX_ENTRY);
12576 if (tmp_rel != irelend)
12577 tmp_rel->r_addend |= R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG;
12578
12579 clean_nds32_elf_blank ();
12580 }
12581
12582 finish:
12583 if (internal_relocs != NULL
12584 && elf_section_data (sec)->relocs != internal_relocs)
12585 free (internal_relocs);
12586
12587 if (contents != NULL
12588 && elf_section_data (sec)->this_hdr.contents != contents)
12589 free (contents);
12590
12591 if (isymbuf != NULL && symtab_hdr->contents != (bfd_byte *) isymbuf)
12592 free (isymbuf);
12593
12594 return result;
12595
12596 error_return:
12597 result = FALSE;
12598 goto finish;
12599 }
12600
12601 static struct bfd_elf_special_section const nds32_elf_special_sections[] =
12602 {
12603 {".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE},
12604 {".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE},
12605 {NULL, 0, 0, 0, 0}
12606 };
12607
12608 static bfd_boolean
12609 nds32_elf_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
12610 struct bfd_link_info *info,
12611 void *finfo ATTRIBUTE_UNUSED,
12612 bfd_boolean (*func) (void *, const char *,
12613 Elf_Internal_Sym *,
12614 asection *,
12615 struct elf_link_hash_entry *)
12616 ATTRIBUTE_UNUSED)
12617 {
12618 FILE *sym_ld_script = NULL;
12619 struct elf_nds32_link_hash_table *table;
12620
12621 table = nds32_elf_hash_table (info);
12622 sym_ld_script = table->sym_ld_script;
12623
12624 if (check_start_export_sym)
12625 fprintf (sym_ld_script, "}\n");
12626
12627 return TRUE;
12628 }
12629
12630 static enum elf_reloc_type_class
12631 nds32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
12632 const asection *rel_sec ATTRIBUTE_UNUSED,
12633 const Elf_Internal_Rela *rela)
12634 {
12635 switch ((int) ELF32_R_TYPE (rela->r_info))
12636 {
12637 case R_NDS32_RELATIVE:
12638 return reloc_class_relative;
12639 case R_NDS32_JMP_SLOT:
12640 return reloc_class_plt;
12641 case R_NDS32_COPY:
12642 return reloc_class_copy;
12643 default:
12644 return reloc_class_normal;
12645 }
12646 }
12647
12648 /* Put target dependent option into info hash table. */
12649 void
12650 bfd_elf32_nds32_set_target_option (struct bfd_link_info *link_info,
12651 int relax_fp_as_gp,
12652 int eliminate_gc_relocs,
12653 FILE * sym_ld_script,
12654 int hyper_relax,
12655 int tls_desc_trampoline,
12656 int load_store_relax)
12657 {
12658 struct elf_nds32_link_hash_table *table;
12659
12660 table = nds32_elf_hash_table (link_info);
12661 if (table == NULL)
12662 return;
12663
12664 table->relax_fp_as_gp = relax_fp_as_gp;
12665 table->eliminate_gc_relocs = eliminate_gc_relocs;
12666 table->sym_ld_script = sym_ld_script;
12667 table->hyper_relax = hyper_relax;
12668 table->tls_desc_trampoline = tls_desc_trampoline;
12669 table ->load_store_relax = load_store_relax;
12670 }
12671 \f
12672
12673 /* These functions and data-structures are used for fp-as-gp
12674 optimization. */
12675
12676 #define FAG_THRESHOLD 3 /* At least 3 gp-access. */
12677 /* lwi37.fp covers 508 bytes, but there may be 32-byte padding between
12678 the read-only section and read-write section. */
12679 #define FAG_WINDOW (508 - 32)
12680
12681 /* An nds32_fag represent a gp-relative access.
12682 We find best fp-base by using a sliding window
12683 to find a base address which can cover most gp-access. */
12684 struct nds32_fag
12685 {
12686 struct nds32_fag *next; /* NULL-teminated linked list. */
12687 bfd_vma addr; /* The address of this fag. */
12688 Elf_Internal_Rela **relas; /* The relocations associated with this fag.
12689 It is used for applying FP7U2_FLAG. */
12690 int count; /* How many times this address is referred.
12691 There should be exactly `count' relocations
12692 in relas. */
12693 int relas_capcity; /* The buffer size of relas.
12694 We use an array instead of linked-list,
12695 and realloc is used to adjust buffer size. */
12696 };
12697
12698 static void
12699 nds32_fag_init (struct nds32_fag *head)
12700 {
12701 memset (head, 0, sizeof (struct nds32_fag));
12702 }
12703
12704 static void
12705 nds32_fag_verify (struct nds32_fag *head)
12706 {
12707 struct nds32_fag *iter;
12708 struct nds32_fag *prev;
12709
12710 prev = NULL;
12711 iter = head->next;
12712 while (iter)
12713 {
12714 if (prev && prev->addr >= iter->addr)
12715 puts ("Bug in fp-as-gp insertion.");
12716 prev = iter;
12717 iter = iter->next;
12718 }
12719 }
12720
12721 /* Insert a fag in ascending order.
12722 If a fag of the same address already exists,
12723 they are chained by relas array. */
12724
12725 static void
12726 nds32_fag_insert (struct nds32_fag *head, bfd_vma addr,
12727 Elf_Internal_Rela * rel)
12728 {
12729 struct nds32_fag *iter;
12730 struct nds32_fag *new_fag;
12731 const int INIT_RELAS_CAP = 4;
12732
12733 for (iter = head;
12734 iter->next && iter->next->addr <= addr;
12735 iter = iter->next)
12736 /* Find somewhere to insert. */ ;
12737
12738 /* `iter' will be equal to `head' if the list is empty. */
12739 if (iter != head && iter->addr == addr)
12740 {
12741 /* The address exists in the list.
12742 Insert `rel' into relocation list, relas. */
12743
12744 /* Check whether relas is big enough. */
12745 if (iter->count >= iter->relas_capcity)
12746 {
12747 iter->relas_capcity *= 2;
12748 iter->relas = bfd_realloc
12749 (iter->relas, iter->relas_capcity * sizeof (void *));
12750 }
12751 iter->relas[iter->count++] = rel;
12752 return;
12753 }
12754
12755 /* This is a new address. Create a fag node for it. */
12756 new_fag = bfd_malloc (sizeof (struct nds32_fag));
12757 memset (new_fag, 0, sizeof (*new_fag));
12758 new_fag->addr = addr;
12759 new_fag->count = 1;
12760 new_fag->next = iter->next;
12761 new_fag->relas_capcity = INIT_RELAS_CAP;
12762 new_fag->relas = (Elf_Internal_Rela **)
12763 bfd_malloc (new_fag->relas_capcity * sizeof (void *));
12764 new_fag->relas[0] = rel;
12765 iter->next = new_fag;
12766
12767 nds32_fag_verify (head);
12768 }
12769
12770 static void
12771 nds32_fag_free_list (struct nds32_fag *head)
12772 {
12773 struct nds32_fag *iter;
12774
12775 iter = head->next;
12776 while (iter)
12777 {
12778 struct nds32_fag *tmp = iter;
12779 iter = iter->next;
12780 free (tmp->relas);
12781 tmp->relas = NULL;
12782 free (tmp);
12783 }
12784 }
12785
12786 /* Find the best fp-base address.
12787 The relocation associated with that address is returned,
12788 so we can track the symbol instead of a fixed address.
12789
12790 When relaxation, the address of an datum may change,
12791 because a text section is shrinked, so the data section
12792 moves forward. If the aligments of text and data section
12793 are different, their distance may change too.
12794 Therefore, tracking a fixed address is not appriate. */
12795
12796 static int
12797 nds32_fag_find_base (struct nds32_fag *head, struct nds32_fag **bestpp)
12798 {
12799 struct nds32_fag *base; /* First fag in the window. */
12800 struct nds32_fag *last; /* First fag outside the window. */
12801 int accu = 0; /* Usage accumulation. */
12802 struct nds32_fag *best; /* Best fag. */
12803 int baccu = 0; /* Best accumulation. */
12804
12805 /* Use first fag for initial, and find the last fag in the window.
12806
12807 In each iteration, we could simply subtract previous fag
12808 and accumulate following fags which are inside the window,
12809 untill we each the end. */
12810
12811 if (head->next == NULL)
12812 {
12813 *bestpp = NULL;
12814 return 0;
12815 }
12816
12817 /* Initialize base. */
12818 base = head->next;
12819 best = base;
12820 for (last = base;
12821 last && last->addr < base->addr + FAG_WINDOW;
12822 last = last->next)
12823 accu += last->count;
12824
12825 baccu = accu;
12826
12827 /* Record the best base in each iteration. */
12828 while (base->next)
12829 {
12830 accu -= base->count;
12831 base = base->next;
12832 /* Account fags in window. */
12833 for (/* Nothing. */;
12834 last && last->addr < base->addr + FAG_WINDOW;
12835 last = last->next)
12836 accu += last->count;
12837
12838 /* A better fp-base? */
12839 if (accu > baccu)
12840 {
12841 best = base;
12842 baccu = accu;
12843 }
12844 }
12845
12846 if (bestpp)
12847 *bestpp = best;
12848 return baccu;
12849 }
12850
12851 /* Apply R_NDS32_INSN16_FP7U2_FLAG on gp-relative accesses,
12852 so we can convert it fo fp-relative access later.
12853 `best_fag' is the best fp-base. Only those inside the window
12854 of best_fag is applied the flag. */
12855
12856 static bfd_boolean
12857 nds32_fag_mark_relax (struct bfd_link_info *link_info,
12858 asection *sec, struct nds32_fag *best_fag,
12859 Elf_Internal_Rela *internal_relocs,
12860 Elf_Internal_Rela *irelend)
12861 {
12862 struct nds32_fag *ifag;
12863 bfd_vma best_fpbase, gp;
12864 bfd *output_bfd;
12865
12866 output_bfd = sec->output_section->owner;
12867 nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
12868 best_fpbase = best_fag->addr;
12869
12870 if (best_fpbase > gp + sdata_range[1][1]
12871 || best_fpbase < gp - sdata_range[1][0])
12872 return FALSE;
12873
12874 /* Mark these inside the window R_NDS32_INSN16_FP7U2_FLAG flag,
12875 so we know they can be converted to lwi37.fp. */
12876 for (ifag = best_fag;
12877 ifag && ifag->addr < best_fpbase + FAG_WINDOW; ifag = ifag->next)
12878 {
12879 int i;
12880
12881 for (i = 0; i < ifag->count; i++)
12882 {
12883 Elf_Internal_Rela *insn16_rel;
12884 Elf_Internal_Rela *fag_rel;
12885
12886 fag_rel = ifag->relas[i];
12887
12888 /* Only if this is within the WINDOWS, FP7U2_FLAG
12889 is applied. */
12890
12891 insn16_rel = find_relocs_at_address
12892 (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12893
12894 if (insn16_rel != irelend)
12895 insn16_rel->r_addend = R_NDS32_INSN16_FP7U2_FLAG;
12896 }
12897 }
12898 return TRUE;
12899 }
12900
12901 /* Reset INSN16 to clean fp as gp. */
12902
12903 static void
12904 nds32_fag_unmark_relax (struct nds32_fag *fag,
12905 Elf_Internal_Rela *internal_relocs,
12906 Elf_Internal_Rela *irelend)
12907 {
12908 struct nds32_fag *ifag;
12909 int i;
12910 Elf_Internal_Rela *insn16_rel;
12911 Elf_Internal_Rela *fag_rel;
12912
12913 for (ifag = fag; ifag; ifag = ifag->next)
12914 {
12915 for (i = 0; i < ifag->count; i++)
12916 {
12917 fag_rel = ifag->relas[i];
12918
12919 /* Restore the INSN16 relocation. */
12920 insn16_rel = find_relocs_at_address
12921 (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12922
12923 if (insn16_rel != irelend)
12924 insn16_rel->r_addend &= ~R_NDS32_INSN16_FP7U2_FLAG;
12925 }
12926 }
12927 }
12928
12929 /* This is the main function of fp-as-gp optimization.
12930 It should be called by relax_section. */
12931
12932 static bfd_boolean
12933 nds32_relax_fp_as_gp (struct bfd_link_info *link_info,
12934 bfd *abfd, asection *sec,
12935 Elf_Internal_Rela *internal_relocs,
12936 Elf_Internal_Rela *irelend,
12937 Elf_Internal_Sym *isymbuf)
12938 {
12939 Elf_Internal_Rela *begin_rel = NULL;
12940 Elf_Internal_Rela *irel;
12941 struct nds32_fag fag_head;
12942 Elf_Internal_Shdr *symtab_hdr;
12943 bfd_byte *contents;
12944 bfd_boolean ifc_inside = FALSE;
12945
12946 /* FIXME: Can we bfd_elf_link_read_relocs for the relocs? */
12947
12948 /* Per-function fp-base selection.
12949 1. Create a list for all the gp-relative access.
12950 2. Base on those gp-relative address,
12951 find a fp-base which can cover most access.
12952 3. Use the fp-base for fp-as-gp relaxation.
12953
12954 NOTE: If fp-as-gp is not worth to do, (e.g., less than 3 times),
12955 we should
12956 1. delete the `la $fp, _FP_BASE_' instruction and
12957 2. not convert lwi.gp to lwi37.fp.
12958
12959 To delete the _FP_BASE_ instruction, we simply apply
12960 R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG flag in the r_addend to disable it.
12961
12962 To suppress the conversion, we simply NOT to apply
12963 R_NDS32_INSN16_FP7U2_FLAG flag. */
12964
12965 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12966
12967 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12968 || !nds32_get_local_syms (abfd, sec, &isymbuf))
12969 return FALSE;
12970
12971 /* Check whether it is worth for fp-as-gp optimization,
12972 i.e., at least 3 gp-load.
12973
12974 Set R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG if we should NOT
12975 apply this optimization. */
12976
12977 for (irel = internal_relocs; irel < irelend; irel++)
12978 {
12979 /* We recognize R_NDS32_RELAX_REGION_BEGIN/_END for the region.
12980 One we enter the begin of the region, we track all the LW/ST
12981 instructions, so when we leave the region, we try to find
12982 the best fp-base address for those LW/ST instructions. */
12983
12984 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12985 && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12986 {
12987 /* Begin of the region. */
12988 if (begin_rel)
12989 /* xgettext:c-format */
12990 _bfd_error_handler (_("%pB: nested OMIT_FP in %pA"), abfd, sec);
12991
12992 begin_rel = irel;
12993 nds32_fag_init (&fag_head);
12994 ifc_inside = FALSE;
12995 }
12996 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
12997 && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12998 {
12999 int accu;
13000 struct nds32_fag *best_fag, *tmp_fag;
13001 int dist;
13002
13003 /* End of the region.
13004 Check whether it is worth to do fp-as-gp. */
13005
13006 if (begin_rel == NULL)
13007 {
13008 /* xgettext:c-format */
13009 _bfd_error_handler (_("%pB: unmatched OMIT_FP in %pA"),
13010 abfd, sec);
13011 continue;
13012 }
13013
13014 accu = nds32_fag_find_base (&fag_head, &best_fag);
13015
13016 /* Clean FP7U2_FLAG because they may set ever. */
13017 tmp_fag = fag_head.next;
13018 nds32_fag_unmark_relax (tmp_fag, internal_relocs, irelend);
13019
13020 /* Check if it is worth, and FP_BASE is near enough to SDA_BASE. */
13021 if (accu < FAG_THRESHOLD
13022 || !nds32_fag_mark_relax (link_info, sec, best_fag,
13023 internal_relocs, irelend))
13024 {
13025 /* Not worth to do fp-as-gp. */
13026 begin_rel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
13027 begin_rel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
13028 irel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
13029 irel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
13030 nds32_fag_free_list (&fag_head);
13031 begin_rel = NULL;
13032 continue;
13033 }
13034
13035 /* R_SYM of R_NDS32_RELAX_REGION_BEGIN is not used by assembler,
13036 so we use it to record the distance to the reloction of best
13037 fp-base. */
13038 dist = best_fag->relas[0] - begin_rel;
13039 BFD_ASSERT (dist > 0 && dist < 0xffffff);
13040 /* Use high 16 bits of addend to record the _FP_BASE_ matched
13041 relocation. And get the base value when relocating. */
13042 begin_rel->r_addend &= (0x1 << 16) - 1;
13043 begin_rel->r_addend |= dist << 16;
13044
13045 nds32_fag_free_list (&fag_head);
13046 begin_rel = NULL;
13047 }
13048
13049 if (begin_rel == NULL || ifc_inside)
13050 /* Skip if we are not in the region of fp-as-gp. */
13051 continue;
13052
13053 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S2_RELA
13054 || ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA17S2_RELA)
13055 {
13056 bfd_vma addr;
13057 uint32_t insn;
13058
13059 /* A gp-relative access is found. Insert it to the fag-list. */
13060
13061 /* Rt is necessary an RT3, so it can be converted to lwi37.fp. */
13062 insn = bfd_getb32 (contents + irel->r_offset);
13063 if (!N32_IS_RT3 (insn))
13064 continue;
13065
13066 addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
13067 nds32_fag_insert (&fag_head, addr, irel);
13068 }
13069 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA_FP7U2_RELA)
13070 {
13071 begin_rel = NULL;
13072 }
13073 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
13074 || ELF32_R_TYPE (irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
13075 {
13076 /* Suppress fp as gp when encounter ifc. */
13077 ifc_inside = TRUE;
13078 }
13079 }
13080
13081 return TRUE;
13082 }
13083
13084 /* Remove unused `la $fp, _FD_BASE_' instruction. */
13085
13086 static bfd_boolean
13087 nds32_fag_remove_unused_fpbase (bfd *abfd, asection *sec,
13088 Elf_Internal_Rela *internal_relocs,
13089 Elf_Internal_Rela *irelend)
13090 {
13091 Elf_Internal_Rela *irel;
13092 Elf_Internal_Shdr *symtab_hdr;
13093 bfd_byte *contents = NULL;
13094 nds32_elf_blank_t *relax_blank_list = NULL;
13095 bfd_boolean result = TRUE;
13096 bfd_boolean unused_region = FALSE;
13097
13098 /*
13099 NOTE: Disable fp-as-gp if we encounter ifcall relocations:
13100 R_NDS32_17IFC_PCREL_RELA
13101 R_NDS32_10IFCU_PCREL_RELA. */
13102
13103 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13104 nds32_get_section_contents (abfd, sec, &contents, TRUE);
13105
13106 for (irel = internal_relocs; irel < irelend; irel++)
13107 {
13108 /* To remove unused fp-base, we simply find the REGION_NOT_OMIT_FP
13109 we marked to in previous pass.
13110 DO NOT scan relocations again, since we've alreadly decided it
13111 and set the flag. */
13112 const char *syname;
13113 int syndx;
13114 uint32_t insn;
13115
13116 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
13117 && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
13118 unused_region = TRUE;
13119 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
13120 && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
13121 unused_region = FALSE;
13122
13123 /* We're not in the region. */
13124 if (!unused_region)
13125 continue;
13126
13127 /* _FP_BASE_ must be a GLOBAL symbol. */
13128 syndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
13129 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
13130 continue;
13131
13132 /* The symbol name must be _FP_BASE_. */
13133 syname = elf_sym_hashes (abfd)[syndx]->root.root.string;
13134 if (strcmp (syname, FP_BASE_NAME) != 0)
13135 continue;
13136
13137 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA19S0_RELA)
13138 {
13139 /* addi.gp $fp, -256 */
13140 insn = bfd_getb32 (contents + irel->r_offset);
13141 if (insn != INSN_ADDIGP_TO_FP)
13142 continue;
13143 }
13144 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S0_RELA)
13145 {
13146 /* addi $fp, $gp, -256 */
13147 insn = bfd_getb32 (contents + irel->r_offset);
13148 if (insn != INSN_ADDI_GP_TO_FP)
13149 continue;
13150 }
13151 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_20_RELA)
13152 {
13153 /* movi $fp, FP_BASE */
13154 insn = bfd_getb32 (contents + irel->r_offset);
13155 if (insn != INSN_MOVI_TO_FP)
13156 continue;
13157 }
13158 else
13159 continue;
13160
13161 /* We got here because a FP_BASE instruction is found. */
13162 if (!insert_nds32_elf_blank_recalc_total
13163 (&relax_blank_list, irel->r_offset, 4))
13164 goto error_return;
13165 }
13166
13167 finish:
13168 if (relax_blank_list)
13169 {
13170 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
13171 relax_blank_list = NULL;
13172 }
13173 return result;
13174
13175 error_return:
13176 result = FALSE;
13177 goto finish;
13178 }
13179
13180 /* This is a version of bfd_generic_get_relocated_section_contents.
13181 We need this variety because relaxation will modify the dwarf
13182 infomation. When there is undefined symbol reference error mesage,
13183 linker need to dump line number where the symbol be used. However
13184 the address is be relaxed, it can not get the original dwarf contents.
13185 The variety only modify function call for reading in the section. */
13186
13187 static bfd_byte *
13188 nds32_elf_get_relocated_section_contents (bfd *abfd,
13189 struct bfd_link_info *link_info,
13190 struct bfd_link_order *link_order,
13191 bfd_byte *data,
13192 bfd_boolean relocatable,
13193 asymbol **symbols)
13194 {
13195 bfd *input_bfd = link_order->u.indirect.section->owner;
13196 asection *input_section = link_order->u.indirect.section;
13197 long reloc_size;
13198 arelent **reloc_vector;
13199 long reloc_count;
13200
13201 reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
13202 if (reloc_size < 0)
13203 return NULL;
13204
13205 /* Read in the section. */
13206 if (!nds32_get_section_contents (input_bfd, input_section, &data, FALSE))
13207 return NULL;
13208
13209 if (reloc_size == 0)
13210 return data;
13211
13212 reloc_vector = (arelent **) bfd_malloc (reloc_size);
13213 if (reloc_vector == NULL)
13214 return NULL;
13215
13216 reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
13217 reloc_vector, symbols);
13218 if (reloc_count < 0)
13219 goto error_return;
13220
13221 if (reloc_count > 0)
13222 {
13223 arelent **parent;
13224 for (parent = reloc_vector; *parent != NULL; parent++)
13225 {
13226 char *error_message = NULL;
13227 asymbol *symbol;
13228 bfd_reloc_status_type r;
13229
13230 symbol = *(*parent)->sym_ptr_ptr;
13231 if (symbol->section && discarded_section (symbol->section))
13232 {
13233 bfd_byte *p;
13234 static reloc_howto_type none_howto
13235 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL,
13236 "unused", FALSE, 0, 0, FALSE);
13237
13238 p = data + (*parent)->address * bfd_octets_per_byte (input_bfd);
13239 _bfd_clear_contents ((*parent)->howto, input_bfd, input_section,
13240 p);
13241 (*parent)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
13242 (*parent)->addend = 0;
13243 (*parent)->howto = &none_howto;
13244 r = bfd_reloc_ok;
13245 }
13246 else
13247 r = bfd_perform_relocation (input_bfd, *parent, data,
13248 input_section,
13249 relocatable ? abfd : NULL,
13250 &error_message);
13251
13252 if (relocatable)
13253 {
13254 asection *os = input_section->output_section;
13255
13256 /* A partial link, so keep the relocs. */
13257 os->orelocation[os->reloc_count] = *parent;
13258 os->reloc_count++;
13259 }
13260
13261 if (r != bfd_reloc_ok)
13262 {
13263 switch (r)
13264 {
13265 case bfd_reloc_undefined:
13266 (*link_info->callbacks->undefined_symbol)
13267 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13268 input_bfd, input_section, (*parent)->address, TRUE);
13269 break;
13270 case bfd_reloc_dangerous:
13271 BFD_ASSERT (error_message != NULL);
13272 (*link_info->callbacks->reloc_dangerous)
13273 (link_info, error_message,
13274 input_bfd, input_section, (*parent)->address);
13275 break;
13276 case bfd_reloc_overflow:
13277 (*link_info->callbacks->reloc_overflow)
13278 (link_info, NULL,
13279 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13280 (*parent)->howto->name, (*parent)->addend,
13281 input_bfd, input_section, (*parent)->address);
13282 break;
13283 case bfd_reloc_outofrange:
13284 /* PR ld/13730:
13285 This error can result when processing some partially
13286 complete binaries. Do not abort, but issue an error
13287 message instead. */
13288 link_info->callbacks->einfo
13289 /* xgettext:c-format */
13290 (_("%X%P: %pB(%pA): relocation \"%pR\" goes out of range\n"),
13291 abfd, input_section, * parent);
13292 goto error_return;
13293
13294 default:
13295 abort ();
13296 break;
13297 }
13298 }
13299 }
13300 }
13301
13302 free (reloc_vector);
13303 return data;
13304
13305 error_return:
13306 free (reloc_vector);
13307 return NULL;
13308 }
13309
13310 /* Check target symbol. */
13311
13312 static bfd_boolean
13313 nds32_elf_is_target_special_symbol (bfd *abfd ATTRIBUTE_UNUSED, asymbol *sym)
13314 {
13315 if (!sym || !sym->name || sym->name[0] != '$')
13316 return FALSE;
13317 return TRUE;
13318 }
13319
13320 /* nds32 find maybe function sym. Ignore target special symbol
13321 first, and then go the general function. */
13322
13323 static bfd_size_type
13324 nds32_elf_maybe_function_sym (const asymbol *sym, asection *sec,
13325 bfd_vma *code_off)
13326 {
13327 if (nds32_elf_is_target_special_symbol (NULL, (asymbol *) sym))
13328 return 0;
13329
13330 return _bfd_elf_maybe_function_sym (sym, sec, code_off);
13331 }
13332 \f
13333
13334 /* Do TLS model conversion. */
13335
13336 typedef struct relax_group_list_t
13337 {
13338 Elf_Internal_Rela *relo;
13339 struct relax_group_list_t *next;
13340 struct relax_group_list_t *next_sibling;
13341 int id;
13342 } relax_group_list_t;
13343
13344 int
13345 list_insert (relax_group_list_t *pHead, Elf_Internal_Rela *pElem);
13346
13347 int
13348 list_insert_sibling (relax_group_list_t *pNode, Elf_Internal_Rela *pElem);
13349
13350 void
13351 dump_chain (relax_group_list_t *pHead);
13352
13353 int
13354 list_insert (relax_group_list_t *pHead, Elf_Internal_Rela *pElem)
13355 {
13356 relax_group_list_t *pNext = pHead;
13357
13358 /* Find place. */
13359 while (pNext->next)
13360 {
13361 if (pNext->next->id > (int) pElem->r_addend)
13362 break;
13363
13364 pNext = pNext->next;
13365 }
13366
13367 /* Insert node. */
13368 relax_group_list_t *pNew = bfd_malloc (sizeof (relax_group_list_t));
13369 if (!pNew)
13370 return FALSE;
13371
13372 relax_group_list_t *tmp = pNext->next;
13373 pNext->next = pNew;
13374
13375 pNew->id = pElem->r_addend;
13376 pNew->relo = pElem;
13377 pNew->next = tmp;
13378 pNew->next_sibling = NULL;
13379
13380 return TRUE;
13381 }
13382
13383 int
13384 list_insert_sibling (relax_group_list_t *pNode, Elf_Internal_Rela *pElem)
13385 {
13386 relax_group_list_t *pNext = pNode;
13387
13388 /* Find place. */
13389 while (pNext->next_sibling)
13390 {
13391 pNext = pNext->next_sibling;
13392 }
13393
13394 /* Insert node. */
13395 relax_group_list_t *pNew = bfd_malloc (sizeof (relax_group_list_t));
13396 if (!pNew)
13397 return FALSE;
13398
13399 relax_group_list_t *tmp = pNext->next_sibling;
13400 pNext->next_sibling = pNew;
13401
13402 pNew->id = -1;
13403 pNew->relo = pElem;
13404 pNew->next = NULL;
13405 pNew->next_sibling = tmp;
13406
13407 return TRUE;
13408 }
13409
13410 void
13411 dump_chain (relax_group_list_t *pHead)
13412 {
13413 relax_group_list_t *pNext = pHead->next;
13414 while (pNext)
13415 {
13416 printf("group %d @ 0x%08x", pNext->id, (unsigned)pNext->relo->r_offset);
13417 relax_group_list_t *pNextSib = pNext->next_sibling;
13418 while (pNextSib)
13419 {
13420 printf(", %d", (unsigned) ELF32_R_TYPE (pNextSib->relo->r_info));
13421 pNextSib = pNextSib->next_sibling;
13422 }
13423 pNext = pNext->next;
13424 printf("\n");
13425 }
13426 }
13427
13428 /* Check R_NDS32_RELAX_GROUP of each section.
13429 There might be multiple sections in one object file. */
13430
13431 int
13432 elf32_nds32_check_relax_group (bfd *abfd, asection *asec)
13433 {
13434 elf32_nds32_relax_group_t *relax_group_ptr =
13435 elf32_nds32_relax_group_ptr (abfd);
13436
13437 int min_id = relax_group_ptr->min_id;
13438 int max_id = relax_group_ptr->max_id;
13439
13440 Elf_Internal_Rela *rel;
13441 Elf_Internal_Rela *relend;
13442 Elf_Internal_Rela *relocs;
13443 enum elf_nds32_reloc_type rtype;
13444
13445 do
13446 {
13447 /* Relocations MUST be kept in memory, because relaxation adjust them. */
13448 relocs = _bfd_elf_link_read_relocs (abfd, asec, NULL, NULL,
13449 TRUE /* keep_memory */);
13450 if (relocs == NULL)
13451 break;
13452
13453 /* Check R_NDS32_RELAX_GROUP. */
13454 relend = relocs + asec->reloc_count;
13455 for (rel = relocs; rel < relend; rel++)
13456 {
13457 int id;
13458 rtype = ELF32_R_TYPE (rel->r_info);
13459 if (rtype != R_NDS32_RELAX_GROUP)
13460 continue;
13461
13462 id = rel->r_addend;
13463 if (id < min_id)
13464 min_id = id;
13465 else if (id > max_id)
13466 max_id = id;
13467 }
13468 }
13469 while (FALSE);
13470
13471 if ((relocs != NULL) && (elf_section_data (asec)->relocs != relocs))
13472 free (relocs);
13473
13474 if ((min_id != relax_group_ptr->min_id)
13475 || (max_id != relax_group_ptr->max_id))
13476 {
13477 relax_group_ptr->count = max_id - min_id + 1;
13478 BFD_ASSERT(min_id <= relax_group_ptr->min_id);
13479 relax_group_ptr->min_id = min_id;
13480 BFD_ASSERT(max_id >= relax_group_ptr->max_id);
13481 relax_group_ptr->max_id = max_id;
13482 }
13483
13484 return relax_group_ptr->count;
13485 }
13486
13487 /* Reorder RELAX_GROUP ID when command line option '-r' is applied. */
13488 struct section_id_list_t *relax_group_section_id_list = NULL;
13489
13490 struct section_id_list_t *
13491 elf32_nds32_lookup_section_id (int id, struct section_id_list_t **lst_ptr)
13492 {
13493 struct section_id_list_t *result = NULL;
13494 struct section_id_list_t *lst = *lst_ptr;
13495
13496 if (NULL == lst)
13497 {
13498 result = (struct section_id_list_t *) calloc
13499 (1, sizeof (struct section_id_list_t));
13500 BFD_ASSERT (result); /* Feed me. */
13501 result->id = id;
13502 *lst_ptr = result;
13503 }
13504 else
13505 {
13506 struct section_id_list_t *cur = lst;
13507 struct section_id_list_t *prv = NULL;
13508 struct section_id_list_t *sec = NULL;
13509
13510 while (cur)
13511 {
13512 if (cur->id < id)
13513 {
13514 prv = cur;
13515 cur = cur->next;
13516 continue;
13517 }
13518
13519 if (cur->id > id)
13520 {
13521 cur = NULL; /* To insert after prv. */
13522 sec = cur; /* In case prv == NULL. */
13523 }
13524
13525 break;
13526 }
13527
13528 if (NULL == cur)
13529 {
13530 /* Insert after prv. */
13531 result = (struct section_id_list_t *) calloc
13532 (1, sizeof (struct section_id_list_t));
13533 BFD_ASSERT (result); /* Feed me. */
13534 result->id = id;
13535 if (NULL != prv)
13536 {
13537 result->next = prv->next;
13538 prv->next = result;
13539 }
13540 else
13541 {
13542 *lst_ptr = result;
13543 result->next = sec;
13544 }
13545 }
13546 }
13547
13548 return result;
13549 }
13550
13551 int
13552 elf32_nds32_unify_relax_group (bfd *abfd, asection *asec)
13553 {
13554 static int next_relax_group_bias = 0;
13555
13556 elf32_nds32_relax_group_t *relax_group_ptr =
13557 elf32_nds32_relax_group_ptr (abfd);
13558
13559 bfd_boolean result = TRUE;
13560 Elf_Internal_Rela *rel;
13561 Elf_Internal_Rela *relend;
13562 Elf_Internal_Rela *relocs = NULL;
13563 enum elf_nds32_reloc_type rtype;
13564 struct section_id_list_t *node = NULL;
13565 int count = 0;
13566
13567 do
13568 {
13569 if (0 == relax_group_ptr->count)
13570 break;
13571
13572 /* Check if this section has been handled. */
13573 node = elf32_nds32_lookup_section_id (asec->id, &relax_group_section_id_list);
13574 if (NULL == node)
13575 break; /* Hit, the section id has handled. */
13576
13577 /* Relocations MUST be kept in memory, because relaxation adjust them. */
13578 relocs = _bfd_elf_link_read_relocs (abfd, asec, NULL, NULL,
13579 TRUE /* keep_memory */);
13580 if (relocs == NULL)
13581 {
13582 BFD_ASSERT (0); /* feed me */
13583 break;
13584 }
13585
13586 /* Allocate group id bias for this bfd! */
13587 if (0 == relax_group_ptr->init)
13588 {
13589 relax_group_ptr->bias = next_relax_group_bias;
13590 next_relax_group_bias += relax_group_ptr->count;
13591 relax_group_ptr->init = 1;
13592 }
13593
13594 /* Reorder relax group groups. */
13595 relend = relocs + asec->reloc_count;
13596 for (rel = relocs; rel < relend; rel++)
13597 {
13598 rtype = ELF32_R_TYPE(rel->r_info);
13599 if (rtype != R_NDS32_RELAX_GROUP)
13600 continue;
13601
13602 /* Change it. */
13603 rel->r_addend += relax_group_ptr->bias;
13604 /* Debugging count. */
13605 count++;
13606 }
13607 }
13608 while (FALSE);
13609
13610 if (relocs != NULL && elf_section_data (asec)->relocs != relocs)
13611 free (relocs);
13612
13613 return result;
13614 }
13615
13616 int
13617 nds32_elf_unify_tls_model (bfd *inbfd, asection *insec, bfd_byte *incontents,
13618 struct bfd_link_info *lnkinfo)
13619 {
13620 bfd_boolean result = TRUE;
13621 Elf_Internal_Rela *irel;
13622 Elf_Internal_Rela *irelend;
13623 Elf_Internal_Rela *internal_relocs;
13624 unsigned long r_symndx;
13625 enum elf_nds32_reloc_type r_type;
13626
13627 Elf_Internal_Sym *local_syms = NULL;
13628 bfd_byte *contents = NULL;
13629
13630 relax_group_list_t chain = { .id = -1, .next = NULL, .next_sibling = NULL };
13631
13632 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (inbfd)->symtab_hdr;
13633 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
13634 sym_hashes = elf_sym_hashes (inbfd);
13635 sym_hashes_end =
13636 sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
13637 if (!elf_bad_symtab (inbfd))
13638 sym_hashes_end -= symtab_hdr->sh_info;
13639
13640 /* Reorder RELAX_GROUP when command line option '-r' is applied. */
13641 if (bfd_link_relocatable (lnkinfo))
13642 {
13643 elf32_nds32_unify_relax_group (inbfd, insec);
13644 return result;
13645 }
13646
13647 /* Relocations MUST be kept in memory, because relaxation adjust them. */
13648 internal_relocs = _bfd_elf_link_read_relocs (inbfd, insec, NULL, NULL,
13649 TRUE /* keep_memory */);
13650 if (internal_relocs == NULL)
13651 goto error_return;
13652
13653 irelend = internal_relocs + insec->reloc_count;
13654 irel = find_relocs_at_address (internal_relocs, internal_relocs,
13655 irelend, R_NDS32_RELAX_ENTRY);
13656 if (irel == irelend)
13657 goto finish;
13658
13659 /* Chain/remove groups. */
13660 for (irel = internal_relocs; irel < irelend; irel++)
13661 {
13662 r_symndx = ELF32_R_SYM (irel->r_info);
13663 r_type = ELF32_R_TYPE (irel->r_info);
13664 if (r_type != R_NDS32_RELAX_GROUP)
13665 continue;
13666
13667 /* Remove it. */
13668 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_NONE);
13669 /* Chain it now. */
13670 if (!list_insert (&chain, irel))
13671 goto error_return;
13672 }
13673
13674 /* Collect group relocations. */
13675 /* Presume relocations are sorted. */
13676 relax_group_list_t *pNext = chain.next;
13677 while (pNext)
13678 {
13679 for (irel = internal_relocs; irel < irelend; irel++)
13680 {
13681 if (irel->r_offset == pNext->relo->r_offset)
13682 {
13683 /* Ignore Non-TLS relocation types. */
13684 r_type = ELF32_R_TYPE (irel->r_info);
13685 if ((R_NDS32_TLS_LE_HI20 > r_type)
13686 || (R_NDS32_RELAX_ENTRY == r_type))
13687 continue;
13688
13689 if (!list_insert_sibling (pNext, irel))
13690 goto error_return;
13691 }
13692 else if (irel->r_offset > pNext->relo->r_offset)
13693 {
13694 pNext = pNext->next;
13695 if (!pNext)
13696 break;
13697
13698 bfd_vma current_offset = pNext->relo->r_offset;
13699 if (irel->r_offset > current_offset)
13700 irel = internal_relocs; /* restart from head */
13701 else
13702 --irel; /* Check current irel again. */
13703 continue;
13704 }
13705 else
13706 {
13707 /* This shouldn't be reached. */
13708 }
13709 }
13710 if (pNext)
13711 pNext = pNext->next;
13712 }
13713
13714 #ifdef DUBUG_VERBOSE
13715 dump_chain(&chain);
13716 #endif
13717
13718 /* Get symbol table and section content. */
13719 if (incontents)
13720 contents = incontents;
13721 else if (!nds32_get_section_contents (inbfd, insec, &contents, TRUE)
13722 || !nds32_get_local_syms (inbfd, insec, &local_syms))
13723 goto error_return;
13724
13725 char *local_got_tls_type = elf32_nds32_local_got_tls_type (inbfd);
13726
13727 /* Convert TLS model each group if necessary. */
13728 pNext = chain.next;
13729
13730 int cur_grp_id = -1;
13731 int sethi_rt = -1;
13732 int add_rt = -1;
13733 enum elf_nds32_tls_type tls_type, org_tls_type, eff_tls_type;
13734
13735 tls_type = org_tls_type = eff_tls_type = 0;
13736
13737 while (pNext)
13738 {
13739 relax_group_list_t *pNextSig = pNext->next_sibling;
13740 while (pNextSig)
13741 {
13742 struct elf_link_hash_entry *h = NULL;
13743
13744 irel = pNextSig->relo;
13745 r_symndx = ELF32_R_SYM(irel->r_info);
13746 r_type = ELF32_R_TYPE(irel->r_info);
13747
13748 if (pNext->id != cur_grp_id)
13749 {
13750 cur_grp_id = pNext->id;
13751 org_tls_type = get_tls_type (r_type, NULL);
13752 if (r_symndx >= symtab_hdr->sh_info)
13753 {
13754 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
13755 while (h->root.type == bfd_link_hash_indirect
13756 || h->root.type == bfd_link_hash_warning)
13757 h = (struct elf_link_hash_entry *) h->root.u.i.link;
13758 tls_type = ((struct elf_nds32_link_hash_entry *) h)->tls_type;
13759 }
13760 else
13761 {
13762 tls_type = local_got_tls_type
13763 ? local_got_tls_type[r_symndx]
13764 : GOT_NORMAL;
13765 }
13766
13767 eff_tls_type = 1 << (fls (tls_type) - 1);
13768 sethi_rt = N32_RT5(bfd_getb32 (contents + irel->r_offset));
13769 }
13770
13771 if (eff_tls_type != org_tls_type)
13772 {
13773 switch (org_tls_type)
13774 {
13775 /* DESC to IEGP/IE/LE. */
13776 case GOT_TLS_DESC:
13777 switch (eff_tls_type)
13778 {
13779 case GOT_TLS_IE:
13780 switch (r_type)
13781 {
13782 case R_NDS32_TLS_DESC_HI20:
13783 irel->r_info = ELF32_R_INFO(r_symndx,
13784 R_NDS32_TLS_IE_HI20);
13785 break;
13786 case R_NDS32_TLS_DESC_LO12:
13787 irel->r_info = ELF32_R_INFO(r_symndx,
13788 R_NDS32_TLS_IE_LO12);
13789 break;
13790 case R_NDS32_TLS_DESC_ADD:
13791 {
13792 uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13793 add_rt = N32_RT5 (insn);
13794 insn = N32_TYPE2 (LWI, add_rt, sethi_rt, 0);
13795 bfd_putb32 (insn, contents + irel->r_offset);
13796
13797 irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
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,
13803 R_NDS32_RELAX_REMOVE);
13804 break;
13805 case R_NDS32_TLS_DESC_CALL:
13806 {
13807 uint32_t insn = N32_ALU1(ADD, REG_R0, add_rt,
13808 REG_TP);
13809 bfd_putb32 (insn, contents + irel->r_offset);
13810
13811 irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13812 }
13813 break;
13814 case R_NDS32_LOADSTORE:
13815 case R_NDS32_PTR:
13816 case R_NDS32_PTR_RESOLVED:
13817 case R_NDS32_NONE:
13818 case R_NDS32_LABEL:
13819 break;
13820 default:
13821 BFD_ASSERT(0);
13822 break;
13823 }
13824 break;
13825 case GOT_TLS_IEGP:
13826 switch (r_type)
13827 {
13828 case R_NDS32_TLS_DESC_HI20:
13829 irel->r_info = ELF32_R_INFO(r_symndx,
13830 R_NDS32_TLS_IEGP_HI20);
13831 break;
13832 case R_NDS32_TLS_DESC_LO12:
13833 irel->r_info = ELF32_R_INFO(r_symndx,
13834 R_NDS32_TLS_IEGP_LO12);
13835 break;
13836 case R_NDS32_TLS_DESC_ADD:
13837 {
13838 uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13839 add_rt = N32_RT5 (insn);
13840 insn = N32_MEM(LW, add_rt, sethi_rt, REG_GP, 0);
13841 bfd_putb32 (insn, contents + irel->r_offset);
13842
13843 irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13844 }
13845 break;
13846 case R_NDS32_TLS_DESC_FUNC:
13847 bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13848 irel->r_info = ELF32_R_INFO(r_symndx,
13849 R_NDS32_RELAX_REMOVE);
13850 break;
13851 case R_NDS32_TLS_DESC_CALL:
13852 {
13853 uint32_t insn = N32_ALU1(ADD, REG_R0, add_rt,
13854 REG_TP);
13855 bfd_putb32 (insn, contents + irel->r_offset);
13856
13857 irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13858 }
13859 break;
13860 case R_NDS32_LOADSTORE:
13861 case R_NDS32_PTR:
13862 case R_NDS32_PTR_RESOLVED:
13863 case R_NDS32_NONE:
13864 case R_NDS32_LABEL:
13865 break;
13866 default:
13867 BFD_ASSERT(0);
13868 break;
13869 }
13870 break;
13871 case GOT_TLS_LE:
13872 switch (r_type)
13873 {
13874 case R_NDS32_TLS_DESC_HI20:
13875 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_HI20);
13876 break;
13877 case R_NDS32_TLS_DESC_LO12:
13878 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_LO12);
13879 break;
13880 case R_NDS32_TLS_DESC_ADD:
13881 {
13882 uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13883
13884 add_rt = N32_RT5 (insn);
13885 insn = N32_ALU1 (ADD, REG_R0, sethi_rt, REG_TP);
13886 bfd_putb32 (insn, contents + irel->r_offset);
13887
13888 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_ADD);
13889 }
13890 break;
13891 case R_NDS32_TLS_DESC_FUNC:
13892 bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13893 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_RELAX_REMOVE);
13894 break;
13895 case R_NDS32_TLS_DESC_CALL:
13896 bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13897 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_RELAX_REMOVE);
13898 break;
13899 case R_NDS32_LOADSTORE:
13900 case R_NDS32_PTR:
13901 case R_NDS32_PTR_RESOLVED:
13902 case R_NDS32_NONE:
13903 case R_NDS32_LABEL:
13904 break;
13905 default:
13906 BFD_ASSERT(0);
13907 break;
13908 }
13909 break;
13910 default:
13911 break;
13912 }
13913 break;
13914 /* IEGP to IE/LE. */
13915 case GOT_TLS_IEGP:
13916 switch (eff_tls_type)
13917 {
13918 case GOT_TLS_IE:
13919 switch (r_type)
13920 {
13921 case R_NDS32_TLS_IEGP_HI20:
13922 irel->r_info = ELF32_R_INFO(r_symndx,
13923 R_NDS32_TLS_IE_HI20);
13924 break;
13925 case R_NDS32_TLS_IEGP_LO12:
13926 irel->r_info = ELF32_R_INFO(r_symndx,
13927 R_NDS32_TLS_IE_LO12);
13928 break;
13929 case R_NDS32_PTR_RESOLVED:
13930 {
13931 uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13932
13933 add_rt = N32_RT5 (insn);
13934 insn = N32_TYPE2 (LWI, add_rt, sethi_rt, 0);
13935 bfd_putb32 (insn, contents + irel->r_offset);
13936 }
13937 break;
13938 case R_NDS32_TLS_IEGP_LW:
13939 break;
13940 case R_NDS32_LOADSTORE:
13941 case R_NDS32_PTR:
13942 case R_NDS32_NONE:
13943 case R_NDS32_LABEL:
13944 break;
13945 default:
13946 BFD_ASSERT(0);
13947 break;
13948 }
13949 break;
13950 case GOT_TLS_LE:
13951 switch (r_type)
13952 {
13953 case R_NDS32_TLS_IEGP_HI20:
13954 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_HI20);
13955 break;
13956 case R_NDS32_TLS_IEGP_LO12:
13957 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_LO12);
13958 break;
13959 case R_NDS32_TLS_IEGP_LW:
13960 bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13961 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_RELAX_REMOVE);
13962 break;
13963 case R_NDS32_LOADSTORE:
13964 case R_NDS32_PTR:
13965 case R_NDS32_NONE:
13966 case R_NDS32_LABEL:
13967 case R_NDS32_PTR_RESOLVED:
13968 break;
13969 default:
13970 BFD_ASSERT(0);
13971 break;
13972 }
13973 break;
13974 default:
13975 break;
13976 }
13977 break;
13978 /* IE to LE. */
13979 case GOT_TLS_IE:
13980 switch (eff_tls_type)
13981 {
13982 case GOT_TLS_LE:
13983 switch (r_type)
13984 {
13985 case R_NDS32_TLS_IE_HI20:
13986 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_HI20);
13987 break;
13988 case R_NDS32_TLS_IE_LO12S2:
13989 {
13990 uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13991
13992 add_rt = N32_RT5 (insn);
13993 insn = N32_TYPE2 (ORI, add_rt, sethi_rt, 0);
13994 bfd_putb32 (insn, contents + irel->r_offset);
13995
13996 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_LO12);
13997 }
13998 break;
13999 case R_NDS32_LOADSTORE:
14000 case R_NDS32_PTR:
14001 case R_NDS32_NONE:
14002 case R_NDS32_LABEL:
14003 break;
14004 default:
14005 BFD_ASSERT(0);
14006 break;
14007 }
14008 break;
14009 default:
14010 break;
14011 }
14012 break;
14013 default:
14014 break;
14015 }
14016 }
14017 pNextSig = pNextSig->next_sibling;
14018 }
14019
14020 #if 1
14021 pNext = pNext->next;
14022 #else
14023 while (pNext)
14024 {
14025 if (pNext->id != cur_grp_id)
14026 break;
14027 pNext = pNext->next;
14028 }
14029 #endif
14030 }
14031
14032 finish:
14033 if (incontents)
14034 contents = NULL;
14035
14036 if (internal_relocs != NULL
14037 && elf_section_data (insec)->relocs != internal_relocs)
14038 free (internal_relocs);
14039
14040 if (contents != NULL
14041 && elf_section_data (insec)->this_hdr.contents != contents)
14042 free (contents);
14043
14044 if (local_syms != NULL && symtab_hdr->contents != (bfd_byte *) local_syms)
14045 free (local_syms);
14046
14047 if (chain.next)
14048 {
14049 pNext = chain.next;
14050 relax_group_list_t *pDel;
14051 while (pNext)
14052 {
14053 pDel = pNext;
14054 pNext = pNext->next;
14055 free (pDel);
14056 }
14057 }
14058
14059 return result;
14060
14061 error_return:
14062 result = FALSE;
14063 goto finish;
14064 }
14065
14066 /* End TLS model conversion. */
14067
14068 #define ELF_ARCH bfd_arch_nds32
14069 #define ELF_MACHINE_CODE EM_NDS32
14070 #define ELF_MAXPAGESIZE 0x1000
14071 #define ELF_TARGET_ID NDS32_ELF_DATA
14072
14073 #define TARGET_BIG_SYM nds32_elf32_be_vec
14074 #define TARGET_BIG_NAME "elf32-nds32be"
14075 #define TARGET_LITTLE_SYM nds32_elf32_le_vec
14076 #define TARGET_LITTLE_NAME "elf32-nds32le"
14077
14078 #define elf_info_to_howto nds32_info_to_howto
14079 #define elf_info_to_howto_rel nds32_info_to_howto_rel
14080
14081 #define bfd_elf32_bfd_link_hash_table_create nds32_elf_link_hash_table_create
14082 #define bfd_elf32_bfd_merge_private_bfd_data nds32_elf_merge_private_bfd_data
14083 #define bfd_elf32_bfd_print_private_bfd_data nds32_elf_print_private_bfd_data
14084 #define bfd_elf32_bfd_relax_section nds32_elf_relax_section
14085 #define bfd_elf32_bfd_set_private_flags nds32_elf_set_private_flags
14086
14087 #define bfd_elf32_mkobject nds32_elf_mkobject
14088 #define elf_backend_action_discarded nds32_elf_action_discarded
14089 #define elf_backend_add_symbol_hook nds32_elf_add_symbol_hook
14090 #define elf_backend_check_relocs nds32_elf_check_relocs
14091 #define elf_backend_adjust_dynamic_symbol nds32_elf_adjust_dynamic_symbol
14092 #define elf_backend_create_dynamic_sections nds32_elf_create_dynamic_sections
14093 #define elf_backend_finish_dynamic_sections nds32_elf_finish_dynamic_sections
14094 #define elf_backend_finish_dynamic_symbol nds32_elf_finish_dynamic_symbol
14095 #define elf_backend_size_dynamic_sections nds32_elf_size_dynamic_sections
14096 #define elf_backend_relocate_section nds32_elf_relocate_section
14097 #define elf_backend_gc_mark_hook nds32_elf_gc_mark_hook
14098 #define elf_backend_grok_prstatus nds32_elf_grok_prstatus
14099 #define elf_backend_grok_psinfo nds32_elf_grok_psinfo
14100 #define elf_backend_reloc_type_class nds32_elf_reloc_type_class
14101 #define elf_backend_copy_indirect_symbol nds32_elf_copy_indirect_symbol
14102 #define elf_backend_link_output_symbol_hook nds32_elf_output_symbol_hook
14103 #define elf_backend_output_arch_syms nds32_elf_output_arch_syms
14104 #define elf_backend_object_p nds32_elf_object_p
14105 #define elf_backend_final_write_processing nds32_elf_final_write_processing
14106 #define elf_backend_special_sections nds32_elf_special_sections
14107 #define bfd_elf32_bfd_get_relocated_section_contents \
14108 nds32_elf_get_relocated_section_contents
14109 #define bfd_elf32_bfd_is_target_special_symbol nds32_elf_is_target_special_symbol
14110 #define elf_backend_maybe_function_sym nds32_elf_maybe_function_sym
14111
14112 #define elf_backend_can_gc_sections 1
14113 #define elf_backend_can_refcount 1
14114 #define elf_backend_want_got_plt 1
14115 #define elf_backend_plt_readonly 1
14116 #define elf_backend_want_plt_sym 0
14117 #define elf_backend_got_header_size 12
14118 #define elf_backend_may_use_rel_p 1
14119 #define elf_backend_default_use_rela_p 1
14120 #define elf_backend_may_use_rela_p 1
14121 #define elf_backend_dtrel_excludes_plt 0
14122
14123 #include "elf32-target.h"
14124
14125 #undef ELF_MAXPAGESIZE
14126 #define ELF_MAXPAGESIZE 0x2000
14127
14128 #undef TARGET_BIG_SYM
14129 #define TARGET_BIG_SYM nds32_elf32_linux_be_vec
14130 #undef TARGET_BIG_NAME
14131 #define TARGET_BIG_NAME "elf32-nds32be-linux"
14132 #undef TARGET_LITTLE_SYM
14133 #define TARGET_LITTLE_SYM nds32_elf32_linux_le_vec
14134 #undef TARGET_LITTLE_NAME
14135 #define TARGET_LITTLE_NAME "elf32-nds32le-linux"
14136 #undef elf32_bed
14137 #define elf32_bed elf32_nds32_lin_bed
14138
14139 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.325285 seconds and 4 git commands to generate.