?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH 40/57][Arm][OBJDUMP] Add support for MVE instructions: vdup, veor, vfma, vfms...
[binutils-gdb.git] / bfd / elf32-nds32.c
blobd9a429dcd50c3c0eb74dc7c11deabd4bbc9a4345
1 /* NDS32-specific support for 32-bit ELF.
2 Copyright (C) 2012-2019 Free Software Foundation, Inc.
3 Contributed by Andes Technology Corporation.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "bfdlink.h"
26 #include "libbfd.h"
27 #include "elf-bfd.h"
28 #include "libiberty.h"
29 #include "elf/nds32.h"
30 #include "opcode/nds32.h"
31 #include "elf32-nds32.h"
32 #include "opcode/cgen.h"
33 #include "../opcodes/nds32-opc.h"
34
35 /* Relocation HOWTO functions. */
36 static bfd_reloc_status_type nds32_elf_ignore_reloc
37 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
38 static bfd_reloc_status_type nds32_elf_9_pcrel_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type nds32_elf_hi20_reloc
41 (bfd *, arelent *, asymbol *, void *,
42 asection *, bfd *, char **);
43 static bfd_reloc_status_type nds32_elf_lo12_reloc
44 (bfd *, arelent *, asymbol *, void *,
45 asection *, bfd *, char **);
46 static bfd_reloc_status_type nds32_elf_generic_reloc
47 (bfd *, arelent *, asymbol *, void *,
48 asection *, bfd *, char **);
49 static bfd_reloc_status_type nds32_elf_sda15_reloc
50 (bfd *, arelent *, asymbol *, void *,
51 asection *, bfd *, char **);
52
53 /* Helper functions for HOWTO. */
54 static bfd_reloc_status_type nds32_elf_do_9_pcrel_reloc
55 (bfd *, reloc_howto_type *, asection *, bfd_byte *, bfd_vma,
56 asection *, bfd_vma, bfd_vma);
57
58 /* Nds32 helper functions. */
59 static bfd_vma calculate_memory_address
60 (bfd *, Elf_Internal_Rela *, Elf_Internal_Sym *, Elf_Internal_Shdr *);
61 static int nds32_get_section_contents (bfd *, asection *,
62 bfd_byte **, bfd_boolean);
63 static int nds32_get_local_syms (bfd *, asection *ATTRIBUTE_UNUSED,
64 Elf_Internal_Sym **);
65 static bfd_boolean nds32_relax_fp_as_gp
66 (struct bfd_link_info *link_info, bfd *abfd, asection *sec,
67 Elf_Internal_Rela *internal_relocs, Elf_Internal_Rela *irelend,
68 Elf_Internal_Sym *isymbuf);
69 static bfd_boolean nds32_fag_remove_unused_fpbase
70 (bfd *abfd, asection *sec, Elf_Internal_Rela *internal_relocs,
71 Elf_Internal_Rela *irelend);
72
73 enum
74 {
75 MACH_V1 = bfd_mach_n1h,
76 MACH_V2 = bfd_mach_n1h_v2,
77 MACH_V3 = bfd_mach_n1h_v3,
78 MACH_V3M = bfd_mach_n1h_v3m
79 };
80
81 #define MIN(a, b) ((a) > (b) ? (b) : (a))
82 #define MAX(a, b) ((a) > (b) ? (a) : (b))
83
84 /* The name of the dynamic interpreter. This is put in the .interp
85 section. */
86 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
87
88 #define NDS32_GUARD_SEC_P(flags) ((flags) & SEC_ALLOC \
89 && (flags) & SEC_LOAD \
90 && (flags) & SEC_READONLY)
91
92 /* The nop opcode we use. */
93 #define NDS32_NOP32 0x40000009
94 #define NDS32_NOP16 0x9200
95
96 /* The size in bytes of an entry in the procedure linkage table. */
97 #define PLT_ENTRY_SIZE 24
98 #define PLT_HEADER_SIZE 24
99
100 /* The first entry in a procedure linkage table are reserved,
101 and the initial contents are unimportant (we zero them out).
102 Subsequent entries look like this. */
103 #define PLT0_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(.got+4) */
104 #define PLT0_ENTRY_WORD1 0x58f78000 /* ori r15, r25, LO12(.got+4) */
105 #define PLT0_ENTRY_WORD2 0x05178000 /* lwi r17, [r15+0] */
106 #define PLT0_ENTRY_WORD3 0x04f78001 /* lwi r15, [r15+4] */
107 #define PLT0_ENTRY_WORD4 0x4a003c00 /* jr r15 */
108
109 /* $ta is change to $r15 (from $r25). */
110 #define PLT0_PIC_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(got[1]@GOT) */
111 #define PLT0_PIC_ENTRY_WORD1 0x58f78000 /* ori r15, r15, LO12(got[1]@GOT) */
112 #define PLT0_PIC_ENTRY_WORD2 0x40f7f400 /* add r15, gp, r15 */
113 #define PLT0_PIC_ENTRY_WORD3 0x05178000 /* lwi r17, [r15+0] */
114 #define PLT0_PIC_ENTRY_WORD4 0x04f78001 /* lwi r15, [r15+4] */
115 #define PLT0_PIC_ENTRY_WORD5 0x4a003c00 /* jr r15 */
116
117 #define PLT_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(&got[n+3]) */
118 #define PLT_ENTRY_WORD1 0x04f78000 /* lwi r15, r15, LO12(&got[n+3]) */
119 #define PLT_ENTRY_WORD2 0x4a003c00 /* jr r15 */
120 #define PLT_ENTRY_WORD3 0x45000000 /* movi r16, sizeof(RELA) * n */
121 #define PLT_ENTRY_WORD4 0x48000000 /* j .plt0. */
122
123 #define PLT_PIC_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(got[n+3]@GOT) */
124 #define PLT_PIC_ENTRY_WORD1 0x58f78000 /* ori r15, r15, LO12(got[n+3]@GOT) */
125 #define PLT_PIC_ENTRY_WORD2 0x38febc02 /* lw r15, [gp+r15] */
126 #define PLT_PIC_ENTRY_WORD3 0x4a003c00 /* jr r15 */
127 #define PLT_PIC_ENTRY_WORD4 0x45000000 /* movi r16, sizeof(RELA) * n */
128 #define PLT_PIC_ENTRY_WORD5 0x48000000 /* j .plt0 */
129
130 /* These are macros used to get the relocation accurate value. */
131 #define ACCURATE_8BIT_S1 (0x100)
132 #define ACCURATE_U9BIT_S1 (0x400)
133 #define ACCURATE_12BIT_S1 (0x2000)
134 #define ACCURATE_14BIT_S1 (0x4000)
135 #define ACCURATE_19BIT (0x40000)
136
137 /* These are macros used to get the relocation conservative value. */
138 #define CONSERVATIVE_8BIT_S1 (0x100 - 4)
139 #define CONSERVATIVE_14BIT_S1 (0x4000 - 4)
140 #define CONSERVATIVE_16BIT_S1 (0x10000 - 4)
141 #define CONSERVATIVE_24BIT_S1 (0x1000000 - 4)
142 /* These must be more conservative because the address may be in
143 different segment. */
144 #define CONSERVATIVE_15BIT (0x4000 - 0x1000)
145 #define CONSERVATIVE_15BIT_S1 (0x8000 - 0x1000)
146 #define CONSERVATIVE_15BIT_S2 (0x10000 - 0x1000)
147 #define CONSERVATIVE_19BIT (0x40000 - 0x1000)
148 #define CONSERVATIVE_20BIT (0x80000 - 0x1000)
149
150 /* Size of small data/bss sections, used to calculate SDA_BASE. */
151 static long got_size = 0;
152 static int is_SDA_BASE_set = 0;
153
154 /* Convert ELF-VER in eflags to string for debugging purpose. */
155 static const char *const nds32_elfver_strtab[] =
156 {
157 "ELF-1.2",
158 "ELF-1.3",
159 "ELF-1.4",
160 };
161
162 /* The nds32 linker needs to keep track of the number of relocs that it
163 decides to copy in check_relocs for each symbol. This is so that
164 it can discard PC relative relocs if it doesn't need them when
165 linking with -Bsymbolic. We store the information in a field
166 extending the regular ELF linker hash table. */
167
168 /* This structure keeps track of the number of PC relative relocs we
169 have copied for a given symbol. */
170
171 struct elf_nds32_pcrel_relocs_copied
172 {
173 /* Next section. */
174 struct elf_nds32_pcrel_relocs_copied *next;
175 /* A section in dynobj. */
176 asection *section;
177 /* Number of relocs copied in this section. */
178 bfd_size_type count;
179 };
180
181 enum elf_nds32_tls_type
182 {
183 GOT_UNKNOWN = (0),
184 GOT_NORMAL = (1 << 0),
185 GOT_TLS_LE = (1 << 1),
186 GOT_TLS_IE = (1 << 2),
187 GOT_TLS_IEGP = (1 << 3),
188 GOT_TLS_LD = (1 << 4),
189 GOT_TLS_GD = (1 << 5),
190 GOT_TLS_DESC = (1 << 6),
191 };
192
193 /* Nds32 ELF linker hash entry. */
194
195 struct elf_nds32_link_hash_entry
196 {
197 struct elf_link_hash_entry root;
198
199 /* Track dynamic relocs copied for this symbol. */
200 struct elf_dyn_relocs *dyn_relocs;
201
202 /* For checking relocation type. */
203 enum elf_nds32_tls_type tls_type;
204
205 int offset_to_gp;
206 };
207
208 /* Get the nds32 ELF linker hash table from a link_info structure. */
209
210 #define FP_BASE_NAME "_FP_BASE_"
211 static int check_start_export_sym = 0;
212
213 /* The offset for executable tls relaxation. */
214 #define TP_OFFSET 0x0
215
216 typedef struct
217 {
218 int min_id;
219 int max_id;
220 int count;
221 int bias;
222 int init;
223 } elf32_nds32_relax_group_t;
224
225 struct elf_nds32_obj_tdata
226 {
227 struct elf_obj_tdata root;
228
229 /* tls_type for each local got entry. */
230 char *local_got_tls_type;
231
232 /* GOTPLT entries for TLS descriptors. */
233 bfd_vma *local_tlsdesc_gotent;
234
235 /* for R_NDS32_RELAX_GROUP handling. */
236 elf32_nds32_relax_group_t relax_group;
237
238 unsigned int hdr_size;
239 int* offset_to_gp;
240 };
241
242 #define elf_nds32_tdata(bfd) \
243 ((struct elf_nds32_obj_tdata *) (bfd)->tdata.any)
244
245 #define elf32_nds32_local_got_tls_type(bfd) \
246 (elf_nds32_tdata (bfd)->local_got_tls_type)
247
248 #define elf32_nds32_local_gp_offset(bfd) \
249 (elf_nds32_tdata (bfd)->offset_to_gp)
250
251 #define elf32_nds32_hash_entry(ent) ((struct elf_nds32_link_hash_entry *)(ent))
252
253 #define elf32_nds32_relax_group_ptr(bfd) \
254 &(elf_nds32_tdata (bfd)->relax_group)
255
256 static bfd_boolean
257 nds32_elf_mkobject (bfd *abfd)
258 {
259 return bfd_elf_allocate_object (abfd, sizeof (struct elf_nds32_obj_tdata),
260 NDS32_ELF_DATA);
261 }
262
263 /* Relocations used for relocation. */
264 /* Define HOWTO2 (for relocation) and HOWTO3 (for relaxation) to
265 initialize array nds32_elf_howto_table in any order. The benefit
266 is that we can add any new relocations with any numbers and don't
267 need to fill the gap by lots of EMPTY_HOWTO. */
268 #define HOWTO2(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
269 [C] = HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC)
270
271 static reloc_howto_type nds32_elf_howto_table[] =
272 {
273 /* This reloc does nothing. */
274 HOWTO2 (R_NDS32_NONE, /* type */
275 0, /* rightshift */
276 2, /* size (0 = byte, 1 = short, 2 = long) */
277 32, /* bitsize */
278 FALSE, /* pc_relative */
279 0, /* bitpos */
280 complain_overflow_bitfield,/* complain_on_overflow */
281 bfd_elf_generic_reloc, /* special_function */
282 "R_NDS32_NONE", /* name */
283 FALSE, /* partial_inplace */
284 0, /* src_mask */
285 0, /* dst_mask */
286 FALSE), /* pcrel_offset */
287
288 /* A 16 bit absolute relocation. */
289 HOWTO2 (R_NDS32_16, /* type */
290 0, /* rightshift */
291 1, /* size (0 = byte, 1 = short, 2 = long) */
292 16, /* bitsize */
293 FALSE, /* pc_relative */
294 0, /* bitpos */
295 complain_overflow_bitfield,/* complain_on_overflow */
296 nds32_elf_generic_reloc,/* special_function */
297 "R_NDS32_16", /* name */
298 FALSE, /* partial_inplace */
299 0xffff, /* src_mask */
300 0xffff, /* dst_mask */
301 FALSE), /* pcrel_offset */
302
303 /* A 32 bit absolute relocation. */
304 HOWTO2 (R_NDS32_32, /* type */
305 0, /* rightshift */
306 2, /* size (0 = byte, 1 = short, 2 = long) */
307 32, /* bitsize */
308 FALSE, /* pc_relative */
309 0, /* bitpos */
310 complain_overflow_bitfield,/* complain_on_overflow */
311 nds32_elf_generic_reloc,/* special_function */
312 "R_NDS32_32", /* name */
313 FALSE, /* partial_inplace */
314 0xffffffff, /* src_mask */
315 0xffffffff, /* dst_mask */
316 FALSE), /* pcrel_offset */
317
318 /* A 20 bit address. */
319 HOWTO2 (R_NDS32_20, /* type */
320 0, /* rightshift */
321 2, /* size (0 = byte, 1 = short, 2 = long) */
322 20, /* bitsize */
323 FALSE, /* pc_relative */
324 0, /* bitpos */
325 complain_overflow_unsigned,/* complain_on_overflow */
326 nds32_elf_generic_reloc,/* special_function */
327 "R_NDS32_20", /* name */
328 FALSE, /* partial_inplace */
329 0xfffff, /* src_mask */
330 0xfffff, /* dst_mask */
331 FALSE), /* pcrel_offset */
332
333 /* An PC Relative 9-bit relocation, shifted by 2.
334 This reloc is complicated because relocations are relative to pc & -4.
335 i.e. branches in the right insn slot use the address of the left insn
336 slot for pc. */
337 /* It's not clear whether this should have partial_inplace set or not.
338 Branch relaxing in the assembler can store the addend in the insn,
339 and if bfd_install_relocation gets called the addend may get added
340 again. */
341 HOWTO2 (R_NDS32_9_PCREL, /* type */
342 1, /* rightshift */
343 1, /* size (0 = byte, 1 = short, 2 = long) */
344 8, /* bitsize */
345 TRUE, /* pc_relative */
346 0, /* bitpos */
347 complain_overflow_signed,/* complain_on_overflow */
348 nds32_elf_9_pcrel_reloc,/* special_function */
349 "R_NDS32_9_PCREL", /* name */
350 FALSE, /* partial_inplace */
351 0xff, /* src_mask */
352 0xff, /* dst_mask */
353 TRUE), /* pcrel_offset */
354
355 /* A relative 15 bit relocation, right shifted by 1. */
356 HOWTO2 (R_NDS32_15_PCREL, /* type */
357 1, /* rightshift */
358 2, /* size (0 = byte, 1 = short, 2 = long) */
359 14, /* bitsize */
360 TRUE, /* pc_relative */
361 0, /* bitpos */
362 complain_overflow_signed,/* complain_on_overflow */
363 bfd_elf_generic_reloc, /* special_function */
364 "R_NDS32_15_PCREL", /* name */
365 FALSE, /* partial_inplace */
366 0x3fff, /* src_mask */
367 0x3fff, /* dst_mask */
368 TRUE), /* pcrel_offset */
369
370 /* A relative 17 bit relocation, right shifted by 1. */
371 HOWTO2 (R_NDS32_17_PCREL, /* type */
372 1, /* rightshift */
373 2, /* size (0 = byte, 1 = short, 2 = long) */
374 16, /* bitsize */
375 TRUE, /* pc_relative */
376 0, /* bitpos */
377 complain_overflow_signed,/* complain_on_overflow */
378 bfd_elf_generic_reloc, /* special_function */
379 "R_NDS32_17_PCREL", /* name */
380 FALSE, /* partial_inplace */
381 0xffff, /* src_mask */
382 0xffff, /* dst_mask */
383 TRUE), /* pcrel_offset */
384
385 /* A relative 25 bit relocation, right shifted by 1. */
386 /* It's not clear whether this should have partial_inplace set or not.
387 Branch relaxing in the assembler can store the addend in the insn,
388 and if bfd_install_relocation gets called the addend may get added
389 again. */
390 HOWTO2 (R_NDS32_25_PCREL, /* type */
391 1, /* rightshift */
392 2, /* size (0 = byte, 1 = short, 2 = long) */
393 24, /* bitsize */
394 TRUE, /* pc_relative */
395 0, /* bitpos */
396 complain_overflow_signed,/* complain_on_overflow */
397 bfd_elf_generic_reloc, /* special_function */
398 "R_NDS32_25_PCREL", /* name */
399 FALSE, /* partial_inplace */
400 0xffffff, /* src_mask */
401 0xffffff, /* dst_mask */
402 TRUE), /* pcrel_offset */
403
404 /* High 20 bits of address when lower 12 is or'd in. */
405 HOWTO2 (R_NDS32_HI20, /* type */
406 12, /* rightshift */
407 2, /* size (0 = byte, 1 = short, 2 = long) */
408 20, /* bitsize */
409 FALSE, /* pc_relative */
410 0, /* bitpos */
411 complain_overflow_dont,/* complain_on_overflow */
412 nds32_elf_hi20_reloc, /* special_function */
413 "R_NDS32_HI20", /* name */
414 FALSE, /* partial_inplace */
415 0x000fffff, /* src_mask */
416 0x000fffff, /* dst_mask */
417 FALSE), /* pcrel_offset */
418
419 /* Lower 12 bits of address. */
420 HOWTO2 (R_NDS32_LO12S3, /* type */
421 3, /* rightshift */
422 2, /* size (0 = byte, 1 = short, 2 = long) */
423 9, /* bitsize */
424 FALSE, /* pc_relative */
425 0, /* bitpos */
426 complain_overflow_dont,/* complain_on_overflow */
427 nds32_elf_lo12_reloc, /* special_function */
428 "R_NDS32_LO12S3", /* name */
429 FALSE, /* partial_inplace */
430 0x000001ff, /* src_mask */
431 0x000001ff, /* dst_mask */
432 FALSE), /* pcrel_offset */
433
434 /* Lower 12 bits of address. */
435 HOWTO2 (R_NDS32_LO12S2, /* type */
436 2, /* rightshift */
437 2, /* size (0 = byte, 1 = short, 2 = long) */
438 10, /* bitsize */
439 FALSE, /* pc_relative */
440 0, /* bitpos */
441 complain_overflow_dont,/* complain_on_overflow */
442 nds32_elf_lo12_reloc, /* special_function */
443 "R_NDS32_LO12S2", /* name */
444 FALSE, /* partial_inplace */
445 0x000003ff, /* src_mask */
446 0x000003ff, /* dst_mask */
447 FALSE), /* pcrel_offset */
448
449 /* Lower 12 bits of address. */
450 HOWTO2 (R_NDS32_LO12S1, /* type */
451 1, /* rightshift */
452 2, /* size (0 = byte, 1 = short, 2 = long) */
453 11, /* bitsize */
454 FALSE, /* pc_relative */
455 0, /* bitpos */
456 complain_overflow_dont,/* complain_on_overflow */
457 nds32_elf_lo12_reloc, /* special_function */
458 "R_NDS32_LO12S1", /* name */
459 FALSE, /* partial_inplace */
460 0x000007ff, /* src_mask */
461 0x000007ff, /* dst_mask */
462 FALSE), /* pcrel_offset */
463
464 /* Lower 12 bits of address. */
465 HOWTO2 (R_NDS32_LO12S0, /* type */
466 0, /* rightshift */
467 2, /* size (0 = byte, 1 = short, 2 = long) */
468 12, /* bitsize */
469 FALSE, /* pc_relative */
470 0, /* bitpos */
471 complain_overflow_dont,/* complain_on_overflow */
472 nds32_elf_lo12_reloc, /* special_function */
473 "R_NDS32_LO12S0", /* name */
474 FALSE, /* partial_inplace */
475 0x00000fff, /* src_mask */
476 0x00000fff, /* dst_mask */
477 FALSE), /* pcrel_offset */
478
479 /* Small data area 15 bits offset. */
480 HOWTO2 (R_NDS32_SDA15S3, /* type */
481 3, /* rightshift */
482 2, /* size (0 = byte, 1 = short, 2 = long) */
483 15, /* bitsize */
484 FALSE, /* pc_relative */
485 0, /* bitpos */
486 complain_overflow_signed,/* complain_on_overflow */
487 nds32_elf_sda15_reloc, /* special_function */
488 "R_NDS32_SDA15S3", /* name */
489 FALSE, /* partial_inplace */
490 0x00007fff, /* src_mask */
491 0x00007fff, /* dst_mask */
492 FALSE), /* pcrel_offset */
493
494 /* Small data area 15 bits offset. */
495 HOWTO2 (R_NDS32_SDA15S2, /* type */
496 2, /* rightshift */
497 2, /* size (0 = byte, 1 = short, 2 = long) */
498 15, /* bitsize */
499 FALSE, /* pc_relative */
500 0, /* bitpos */
501 complain_overflow_signed,/* complain_on_overflow */
502 nds32_elf_sda15_reloc, /* special_function */
503 "R_NDS32_SDA15S2", /* name */
504 FALSE, /* partial_inplace */
505 0x00007fff, /* src_mask */
506 0x00007fff, /* dst_mask */
507 FALSE), /* pcrel_offset */
508
509 /* Small data area 15 bits offset. */
510 HOWTO2 (R_NDS32_SDA15S1, /* type */
511 1, /* rightshift */
512 2, /* size (0 = byte, 1 = short, 2 = long) */
513 15, /* bitsize */
514 FALSE, /* pc_relative */
515 0, /* bitpos */
516 complain_overflow_signed,/* complain_on_overflow */
517 nds32_elf_sda15_reloc, /* special_function */
518 "R_NDS32_SDA15S1", /* name */
519 FALSE, /* partial_inplace */
520 0x00007fff, /* src_mask */
521 0x00007fff, /* dst_mask */
522 FALSE), /* pcrel_offset */
523
524 /* Small data area 15 bits offset. */
525 HOWTO2 (R_NDS32_SDA15S0, /* type */
526 0, /* rightshift */
527 2, /* size (0 = byte, 1 = short, 2 = long) */
528 15, /* bitsize */
529 FALSE, /* pc_relative */
530 0, /* bitpos */
531 complain_overflow_signed,/* complain_on_overflow */
532 nds32_elf_sda15_reloc, /* special_function */
533 "R_NDS32_SDA15S0", /* name */
534 FALSE, /* partial_inplace */
535 0x00007fff, /* src_mask */
536 0x00007fff, /* dst_mask */
537 FALSE), /* pcrel_offset */
538
539 /* GNU extension to record C++ vtable hierarchy */
540 HOWTO2 (R_NDS32_GNU_VTINHERIT,/* type */
541 0, /* rightshift */
542 2, /* size (0 = byte, 1 = short, 2 = long) */
543 0, /* bitsize */
544 FALSE, /* pc_relative */
545 0, /* bitpos */
546 complain_overflow_dont,/* complain_on_overflow */
547 NULL, /* special_function */
548 "R_NDS32_GNU_VTINHERIT",/* name */
549 FALSE, /* partial_inplace */
550 0, /* src_mask */
551 0, /* dst_mask */
552 FALSE), /* pcrel_offset */
553
554 /* GNU extension to record C++ vtable member usage */
555 HOWTO2 (R_NDS32_GNU_VTENTRY, /* type */
556 0, /* rightshift */
557 2, /* size (0 = byte, 1 = short, 2 = long) */
558 0, /* bitsize */
559 FALSE, /* pc_relative */
560 0, /* bitpos */
561 complain_overflow_dont,/* complain_on_overflow */
562 _bfd_elf_rel_vtable_reloc_fn,/* special_function */
563 "R_NDS32_GNU_VTENTRY", /* name */
564 FALSE, /* partial_inplace */
565 0, /* src_mask */
566 0, /* dst_mask */
567 FALSE), /* pcrel_offset */
568
569 /* A 16 bit absolute relocation. */
570 HOWTO2 (R_NDS32_16_RELA, /* type */
571 0, /* rightshift */
572 1, /* size (0 = byte, 1 = short, 2 = long) */
573 16, /* bitsize */
574 FALSE, /* pc_relative */
575 0, /* bitpos */
576 complain_overflow_bitfield,/* complain_on_overflow */
577 bfd_elf_generic_reloc, /* special_function */
578 "R_NDS32_16_RELA", /* name */
579 FALSE, /* partial_inplace */
580 0xffff, /* src_mask */
581 0xffff, /* dst_mask */
582 FALSE), /* pcrel_offset */
583
584 /* A 32 bit absolute relocation. */
585 HOWTO2 (R_NDS32_32_RELA, /* type */
586 0, /* rightshift */
587 2, /* size (0 = byte, 1 = short, 2 = long) */
588 32, /* bitsize */
589 FALSE, /* pc_relative */
590 0, /* bitpos */
591 complain_overflow_bitfield,/* complain_on_overflow */
592 bfd_elf_generic_reloc, /* special_function */
593 "R_NDS32_32_RELA", /* name */
594 FALSE, /* partial_inplace */
595 0xffffffff, /* src_mask */
596 0xffffffff, /* dst_mask */
597 FALSE), /* pcrel_offset */
598
599 /* A 20 bit address. */
600 HOWTO2 (R_NDS32_20_RELA, /* type */
601 0, /* rightshift */
602 2, /* size (0 = byte, 1 = short, 2 = long) */
603 20, /* bitsize */
604 FALSE, /* pc_relative */
605 0, /* bitpos */
606 complain_overflow_signed,/* complain_on_overflow */
607 bfd_elf_generic_reloc, /* special_function */
608 "R_NDS32_20_RELA", /* name */
609 FALSE, /* partial_inplace */
610 0xfffff, /* src_mask */
611 0xfffff, /* dst_mask */
612 FALSE), /* pcrel_offset */
613
614 HOWTO2 (R_NDS32_9_PCREL_RELA, /* type */
615 1, /* rightshift */
616 1, /* size (0 = byte, 1 = short, 2 = long) */
617 8, /* bitsize */
618 TRUE, /* pc_relative */
619 0, /* bitpos */
620 complain_overflow_signed,/* complain_on_overflow */
621 bfd_elf_generic_reloc, /* special_function */
622 "R_NDS32_9_PCREL_RELA",/* name */
623 FALSE, /* partial_inplace */
624 0xff, /* src_mask */
625 0xff, /* dst_mask */
626 TRUE), /* pcrel_offset */
627
628 /* A relative 15 bit relocation, right shifted by 1. */
629 HOWTO2 (R_NDS32_15_PCREL_RELA,/* type */
630 1, /* rightshift */
631 2, /* size (0 = byte, 1 = short, 2 = long) */
632 14, /* bitsize */
633 TRUE, /* pc_relative */
634 0, /* bitpos */
635 complain_overflow_signed,/* complain_on_overflow */
636 bfd_elf_generic_reloc, /* special_function */
637 "R_NDS32_15_PCREL_RELA",/* name */
638 FALSE, /* partial_inplace */
639 0x3fff, /* src_mask */
640 0x3fff, /* dst_mask */
641 TRUE), /* pcrel_offset */
642
643 /* A relative 17 bit relocation, right shifted by 1. */
644 HOWTO2 (R_NDS32_17_PCREL_RELA,/* type */
645 1, /* rightshift */
646 2, /* size (0 = byte, 1 = short, 2 = long) */
647 16, /* bitsize */
648 TRUE, /* pc_relative */
649 0, /* bitpos */
650 complain_overflow_signed,/* complain_on_overflow */
651 bfd_elf_generic_reloc, /* special_function */
652 "R_NDS32_17_PCREL_RELA",/* name */
653 FALSE, /* partial_inplace */
654 0xffff, /* src_mask */
655 0xffff, /* dst_mask */
656 TRUE), /* pcrel_offset */
657
658 /* A relative 25 bit relocation, right shifted by 2. */
659 HOWTO2 (R_NDS32_25_PCREL_RELA,/* type */
660 1, /* rightshift */
661 2, /* size (0 = byte, 1 = short, 2 = long) */
662 24, /* bitsize */
663 TRUE, /* pc_relative */
664 0, /* bitpos */
665 complain_overflow_signed,/* complain_on_overflow */
666 bfd_elf_generic_reloc, /* special_function */
667 "R_NDS32_25_PCREL_RELA",/* name */
668 FALSE, /* partial_inplace */
669 0xffffff, /* src_mask */
670 0xffffff, /* dst_mask */
671 TRUE), /* pcrel_offset */
672
673 /* High 20 bits of address when lower 16 is or'd in. */
674 HOWTO2 (R_NDS32_HI20_RELA, /* type */
675 12, /* rightshift */
676 2, /* size (0 = byte, 1 = short, 2 = long) */
677 20, /* bitsize */
678 FALSE, /* pc_relative */
679 0, /* bitpos */
680 complain_overflow_dont,/* complain_on_overflow */
681 bfd_elf_generic_reloc, /* special_function */
682 "R_NDS32_HI20_RELA", /* name */
683 FALSE, /* partial_inplace */
684 0x000fffff, /* src_mask */
685 0x000fffff, /* dst_mask */
686 FALSE), /* pcrel_offset */
687
688 /* Lower 12 bits of address. */
689 HOWTO2 (R_NDS32_LO12S3_RELA, /* type */
690 3, /* rightshift */
691 2, /* size (0 = byte, 1 = short, 2 = long) */
692 9, /* bitsize */
693 FALSE, /* pc_relative */
694 0, /* bitpos */
695 complain_overflow_dont,/* complain_on_overflow */
696 bfd_elf_generic_reloc, /* special_function */
697 "R_NDS32_LO12S3_RELA", /* name */
698 FALSE, /* partial_inplace */
699 0x000001ff, /* src_mask */
700 0x000001ff, /* dst_mask */
701 FALSE), /* pcrel_offset */
702
703 /* Lower 12 bits of address. */
704 HOWTO2 (R_NDS32_LO12S2_RELA, /* type */
705 2, /* rightshift */
706 2, /* size (0 = byte, 1 = short, 2 = long) */
707 10, /* bitsize */
708 FALSE, /* pc_relative */
709 0, /* bitpos */
710 complain_overflow_dont,/* complain_on_overflow */
711 bfd_elf_generic_reloc, /* special_function */
712 "R_NDS32_LO12S2_RELA", /* name */
713 FALSE, /* partial_inplace */
714 0x000003ff, /* src_mask */
715 0x000003ff, /* dst_mask */
716 FALSE), /* pcrel_offset */
717
718 /* Lower 12 bits of address. */
719 HOWTO2 (R_NDS32_LO12S1_RELA, /* type */
720 1, /* rightshift */
721 2, /* size (0 = byte, 1 = short, 2 = long) */
722 11, /* bitsize */
723 FALSE, /* pc_relative */
724 0, /* bitpos */
725 complain_overflow_dont,/* complain_on_overflow */
726 bfd_elf_generic_reloc, /* special_function */
727 "R_NDS32_LO12S1_RELA", /* name */
728 FALSE, /* partial_inplace */
729 0x000007ff, /* src_mask */
730 0x000007ff, /* dst_mask */
731 FALSE), /* pcrel_offset */
732
733 /* Lower 12 bits of address. */
734 HOWTO2 (R_NDS32_LO12S0_RELA, /* type */
735 0, /* rightshift */
736 2, /* size (0 = byte, 1 = short, 2 = long) */
737 12, /* bitsize */
738 FALSE, /* pc_relative */
739 0, /* bitpos */
740 complain_overflow_dont,/* complain_on_overflow */
741 bfd_elf_generic_reloc, /* special_function */
742 "R_NDS32_LO12S0_RELA", /* name */
743 FALSE, /* partial_inplace */
744 0x00000fff, /* src_mask */
745 0x00000fff, /* dst_mask */
746 FALSE), /* pcrel_offset */
747
748 /* Small data area 15 bits offset. */
749 HOWTO2 (R_NDS32_SDA15S3_RELA, /* type */
750 3, /* rightshift */
751 2, /* size (0 = byte, 1 = short, 2 = long) */
752 15, /* bitsize */
753 FALSE, /* pc_relative */
754 0, /* bitpos */
755 complain_overflow_signed,/* complain_on_overflow */
756 bfd_elf_generic_reloc, /* special_function */
757 "R_NDS32_SDA15S3_RELA",/* name */
758 FALSE, /* partial_inplace */
759 0x00007fff, /* src_mask */
760 0x00007fff, /* dst_mask */
761 FALSE), /* pcrel_offset */
762
763 /* Small data area 15 bits offset. */
764 HOWTO2 (R_NDS32_SDA15S2_RELA, /* type */
765 2, /* rightshift */
766 2, /* size (0 = byte, 1 = short, 2 = long) */
767 15, /* bitsize */
768 FALSE, /* pc_relative */
769 0, /* bitpos */
770 complain_overflow_signed,/* complain_on_overflow */
771 bfd_elf_generic_reloc, /* special_function */
772 "R_NDS32_SDA15S2_RELA",/* name */
773 FALSE, /* partial_inplace */
774 0x00007fff, /* src_mask */
775 0x00007fff, /* dst_mask */
776 FALSE), /* pcrel_offset */
777
778 HOWTO2 (R_NDS32_SDA15S1_RELA, /* type */
779 1, /* rightshift */
780 2, /* size (0 = byte, 1 = short, 2 = long) */
781 15, /* bitsize */
782 FALSE, /* pc_relative */
783 0, /* bitpos */
784 complain_overflow_signed,/* complain_on_overflow */
785 bfd_elf_generic_reloc, /* special_function */
786 "R_NDS32_SDA15S1_RELA",/* name */
787 FALSE, /* partial_inplace */
788 0x00007fff, /* src_mask */
789 0x00007fff, /* dst_mask */
790 FALSE), /* pcrel_offset */
791
792 HOWTO2 (R_NDS32_SDA15S0_RELA, /* type */
793 0, /* rightshift */
794 2, /* size (0 = byte, 1 = short, 2 = long) */
795 15, /* bitsize */
796 FALSE, /* pc_relative */
797 0, /* bitpos */
798 complain_overflow_signed,/* complain_on_overflow */
799 bfd_elf_generic_reloc, /* special_function */
800 "R_NDS32_SDA15S0_RELA",/* name */
801 FALSE, /* partial_inplace */
802 0x00007fff, /* src_mask */
803 0x00007fff, /* dst_mask */
804 FALSE), /* pcrel_offset */
805
806 /* GNU extension to record C++ vtable hierarchy */
807 HOWTO2 (R_NDS32_RELA_GNU_VTINHERIT,/* type */
808 0, /* rightshift */
809 2, /* size (0 = byte, 1 = short, 2 = long) */
810 0, /* bitsize */
811 FALSE, /* pc_relative */
812 0, /* bitpos */
813 complain_overflow_dont,/* complain_on_overflow */
814 NULL, /* special_function */
815 "R_NDS32_RELA_GNU_VTINHERIT",/* name */
816 FALSE, /* partial_inplace */
817 0, /* src_mask */
818 0, /* dst_mask */
819 FALSE), /* pcrel_offset */
820
821 /* GNU extension to record C++ vtable member usage */
822 HOWTO2 (R_NDS32_RELA_GNU_VTENTRY,/* type */
823 0, /* rightshift */
824 2, /* size (0 = byte, 1 = short, 2 = long) */
825 0, /* bitsize */
826 FALSE, /* pc_relative */
827 0, /* bitpos */
828 complain_overflow_dont,/* complain_on_overflow */
829 _bfd_elf_rel_vtable_reloc_fn,/* special_function */
830 "R_NDS32_RELA_GNU_VTENTRY",/* name */
831 FALSE, /* partial_inplace */
832 0, /* src_mask */
833 0, /* dst_mask */
834 FALSE), /* pcrel_offset */
835
836 /* Like R_NDS32_20, but referring to the GOT table entry for
837 the symbol. */
838 HOWTO2 (R_NDS32_GOT20, /* type */
839 0, /* rightshift */
840 2, /* size (0 = byte, 1 = short, 2 = long) */
841 20, /* bitsize */
842 FALSE, /* pc_relative */
843 0, /* bitpos */
844 complain_overflow_signed,/* complain_on_overflow */
845 bfd_elf_generic_reloc, /* special_function */
846 "R_NDS32_GOT20", /* name */
847 FALSE, /* partial_inplace */
848 0xfffff, /* src_mask */
849 0xfffff, /* dst_mask */
850 FALSE), /* pcrel_offset */
851
852 /* Like R_NDS32_PCREL, but referring to the procedure linkage table
853 entry for the symbol. */
854 HOWTO2 (R_NDS32_25_PLTREL, /* type */
855 1, /* rightshift */
856 2, /* size (0 = byte, 1 = short, 2 = long) */
857 24, /* bitsize */
858 TRUE, /* pc_relative */
859 0, /* bitpos */
860 complain_overflow_signed,/* complain_on_overflow */
861 bfd_elf_generic_reloc, /* special_function */
862 "R_NDS32_25_PLTREL", /* name */
863 FALSE, /* partial_inplace */
864 0xffffff, /* src_mask */
865 0xffffff, /* dst_mask */
866 TRUE), /* pcrel_offset */
867
868 /* This is used only by the dynamic linker. The symbol should exist
869 both in the object being run and in some shared library. The
870 dynamic linker copies the data addressed by the symbol from the
871 shared library into the object, because the object being
872 run has to have the data at some particular address. */
873 HOWTO2 (R_NDS32_COPY, /* type */
874 0, /* rightshift */
875 2, /* size (0 = byte, 1 = short, 2 = long) */
876 32, /* bitsize */
877 FALSE, /* pc_relative */
878 0, /* bitpos */
879 complain_overflow_bitfield,/* complain_on_overflow */
880 bfd_elf_generic_reloc, /* special_function */
881 "R_NDS32_COPY", /* name */
882 FALSE, /* partial_inplace */
883 0xffffffff, /* src_mask */
884 0xffffffff, /* dst_mask */
885 FALSE), /* pcrel_offset */
886
887 /* Like R_NDS32_20, but used when setting global offset table
888 entries. */
889 HOWTO2 (R_NDS32_GLOB_DAT, /* type */
890 0, /* rightshift */
891 2, /* size (0 = byte, 1 = short, 2 = long) */
892 32, /* bitsize */
893 FALSE, /* pc_relative */
894 0, /* bitpos */
895 complain_overflow_bitfield,/* complain_on_overflow */
896 bfd_elf_generic_reloc, /* special_function */
897 "R_NDS32_GLOB_DAT", /* name */
898 FALSE, /* partial_inplace */
899 0xffffffff, /* src_mask */
900 0xffffffff, /* dst_mask */
901 FALSE), /* pcrel_offset */
902
903 /* Marks a procedure linkage table entry for a symbol. */
904 HOWTO2 (R_NDS32_JMP_SLOT, /* type */
905 0, /* rightshift */
906 2, /* size (0 = byte, 1 = short, 2 = long) */
907 32, /* bitsize */
908 FALSE, /* pc_relative */
909 0, /* bitpos */
910 complain_overflow_bitfield,/* complain_on_overflow */
911 bfd_elf_generic_reloc, /* special_function */
912 "R_NDS32_JMP_SLOT", /* name */
913 FALSE, /* partial_inplace */
914 0xffffffff, /* src_mask */
915 0xffffffff, /* dst_mask */
916 FALSE), /* pcrel_offset */
917
918 /* Used only by the dynamic linker. When the object is run, this
919 longword is set to the load address of the object, plus the
920 addend. */
921 HOWTO2 (R_NDS32_RELATIVE, /* type */
922 0, /* rightshift */
923 2, /* size (0 = byte, 1 = short, 2 = long) */
924 32, /* bitsize */
925 FALSE, /* pc_relative */
926 0, /* bitpos */
927 complain_overflow_bitfield,/* complain_on_overflow */
928 bfd_elf_generic_reloc, /* special_function */
929 "R_NDS32_RELATIVE", /* name */
930 FALSE, /* partial_inplace */
931 0xffffffff, /* src_mask */
932 0xffffffff, /* dst_mask */
933 FALSE), /* pcrel_offset */
934
935 HOWTO2 (R_NDS32_GOTOFF, /* type */
936 0, /* rightshift */
937 2, /* size (0 = byte, 1 = short, 2 = long) */
938 20, /* bitsize */
939 FALSE, /* pc_relative */
940 0, /* bitpos */
941 complain_overflow_signed,/* complain_on_overflow */
942 bfd_elf_generic_reloc, /* special_function */
943 "R_NDS32_GOTOFF", /* name */
944 FALSE, /* partial_inplace */
945 0xfffff, /* src_mask */
946 0xfffff, /* dst_mask */
947 FALSE), /* pcrel_offset */
948
949 /* An PC Relative 20-bit relocation used when setting PIC offset
950 table register. */
951 HOWTO2 (R_NDS32_GOTPC20, /* type */
952 0, /* rightshift */
953 2, /* size (0 = byte, 1 = short, 2 = long) */
954 20, /* bitsize */
955 TRUE, /* pc_relative */
956 0, /* bitpos */
957 complain_overflow_signed,/* complain_on_overflow */
958 bfd_elf_generic_reloc, /* special_function */
959 "R_NDS32_GOTPC20", /* name */
960 FALSE, /* partial_inplace */
961 0xfffff, /* src_mask */
962 0xfffff, /* dst_mask */
963 TRUE), /* pcrel_offset */
964
965 /* Like R_NDS32_HI20, but referring to the GOT table entry for
966 the symbol. */
967 HOWTO2 (R_NDS32_GOT_HI20, /* type */
968 12, /* rightshift */
969 2, /* size (0 = byte, 1 = short, 2 = long) */
970 20, /* bitsize */
971 FALSE, /* pc_relative */
972 0, /* bitpos */
973 complain_overflow_dont,/* complain_on_overflow */
974 bfd_elf_generic_reloc, /* special_function */
975 "R_NDS32_GOT_HI20", /* name */
976 FALSE, /* partial_inplace */
977 0x000fffff, /* src_mask */
978 0x000fffff, /* dst_mask */
979 FALSE), /* pcrel_offset */
980 HOWTO2 (R_NDS32_GOT_LO12, /* type */
981 0, /* rightshift */
982 2, /* size (0 = byte, 1 = short, 2 = long) */
983 12, /* bitsize */
984 FALSE, /* pc_relative */
985 0, /* bitpos */
986 complain_overflow_dont,/* complain_on_overflow */
987 bfd_elf_generic_reloc, /* special_function */
988 "R_NDS32_GOT_LO12", /* name */
989 FALSE, /* partial_inplace */
990 0x00000fff, /* src_mask */
991 0x00000fff, /* dst_mask */
992 FALSE), /* pcrel_offset */
993
994 /* An PC Relative relocation used when setting PIC offset table register.
995 Like R_NDS32_HI20, but referring to the GOT table entry for
996 the symbol. */
997 HOWTO2 (R_NDS32_GOTPC_HI20, /* type */
998 12, /* rightshift */
999 2, /* size (0 = byte, 1 = short, 2 = long) */
1000 20, /* bitsize */
1001 FALSE, /* pc_relative */
1002 0, /* bitpos */
1003 complain_overflow_dont,/* complain_on_overflow */
1004 bfd_elf_generic_reloc, /* special_function */
1005 "R_NDS32_GOTPC_HI20", /* name */
1006 FALSE, /* partial_inplace */
1007 0x000fffff, /* src_mask */
1008 0x000fffff, /* dst_mask */
1009 TRUE), /* pcrel_offset */
1010 HOWTO2 (R_NDS32_GOTPC_LO12, /* type */
1011 0, /* rightshift */
1012 2, /* size (0 = byte, 1 = short, 2 = long) */
1013 12, /* bitsize */
1014 FALSE, /* pc_relative */
1015 0, /* bitpos */
1016 complain_overflow_dont,/* complain_on_overflow */
1017 bfd_elf_generic_reloc, /* special_function */
1018 "R_NDS32_GOTPC_LO12", /* name */
1019 FALSE, /* partial_inplace */
1020 0x00000fff, /* src_mask */
1021 0x00000fff, /* dst_mask */
1022 TRUE), /* pcrel_offset */
1023
1024 HOWTO2 (R_NDS32_GOTOFF_HI20, /* type */
1025 12, /* rightshift */
1026 2, /* size (0 = byte, 1 = short, 2 = long) */
1027 20, /* bitsize */
1028 FALSE, /* pc_relative */
1029 0, /* bitpos */
1030 complain_overflow_dont,/* complain_on_overflow */
1031 bfd_elf_generic_reloc, /* special_function */
1032 "R_NDS32_GOTOFF_HI20", /* name */
1033 FALSE, /* partial_inplace */
1034 0x000fffff, /* src_mask */
1035 0x000fffff, /* dst_mask */
1036 FALSE), /* pcrel_offset */
1037 HOWTO2 (R_NDS32_GOTOFF_LO12, /* type */
1038 0, /* rightshift */
1039 2, /* size (0 = byte, 1 = short, 2 = long) */
1040 12, /* bitsize */
1041 FALSE, /* pc_relative */
1042 0, /* bitpos */
1043 complain_overflow_dont,/* complain_on_overflow */
1044 bfd_elf_generic_reloc, /* special_function */
1045 "R_NDS32_GOTOFF_LO12", /* name */
1046 FALSE, /* partial_inplace */
1047 0x00000fff, /* src_mask */
1048 0x00000fff, /* dst_mask */
1049 FALSE), /* pcrel_offset */
1050
1051 /* Alignment hint for relaxable instruction. This is used with
1052 R_NDS32_LABEL as a pair. Relax this instruction from 4 bytes to 2
1053 in order to make next label aligned on word boundary. */
1054 HOWTO2 (R_NDS32_INSN16, /* type */
1055 0, /* rightshift */
1056 2, /* size (0 = byte, 1 = short, 2 = long) */
1057 32, /* bitsize */
1058 FALSE, /* pc_relative */
1059 0, /* bitpos */
1060 complain_overflow_dont,/* complain_on_overflow */
1061 nds32_elf_ignore_reloc,/* special_function */
1062 "R_NDS32_INSN16", /* name */
1063 FALSE, /* partial_inplace */
1064 0x00000fff, /* src_mask */
1065 0x00000fff, /* dst_mask */
1066 FALSE), /* pcrel_offset */
1067
1068 /* Alignment hint for label. */
1069 HOWTO2 (R_NDS32_LABEL, /* type */
1070 0, /* rightshift */
1071 2, /* size (0 = byte, 1 = short, 2 = long) */
1072 32, /* bitsize */
1073 FALSE, /* pc_relative */
1074 0, /* bitpos */
1075 complain_overflow_dont,/* complain_on_overflow */
1076 nds32_elf_ignore_reloc,/* special_function */
1077 "R_NDS32_LABEL", /* name */
1078 FALSE, /* partial_inplace */
1079 0xffffffff, /* src_mask */
1080 0xffffffff, /* dst_mask */
1081 FALSE), /* pcrel_offset */
1082
1083 /* Relax hint for unconditional call sequence */
1084 HOWTO2 (R_NDS32_LONGCALL1, /* type */
1085 0, /* rightshift */
1086 2, /* size (0 = byte, 1 = short, 2 = long) */
1087 32, /* bitsize */
1088 FALSE, /* pc_relative */
1089 0, /* bitpos */
1090 complain_overflow_dont,/* complain_on_overflow */
1091 nds32_elf_ignore_reloc,/* special_function */
1092 "R_NDS32_LONGCALL1", /* name */
1093 FALSE, /* partial_inplace */
1094 0xffffffff, /* src_mask */
1095 0xffffffff, /* dst_mask */
1096 FALSE), /* pcrel_offset */
1097
1098 /* Relax hint for conditional call sequence. */
1099 HOWTO2 (R_NDS32_LONGCALL2, /* type */
1100 0, /* rightshift */
1101 2, /* size (0 = byte, 1 = short, 2 = long) */
1102 32, /* bitsize */
1103 FALSE, /* pc_relative */
1104 0, /* bitpos */
1105 complain_overflow_dont,/* complain_on_overflow */
1106 nds32_elf_ignore_reloc,/* special_function */
1107 "R_NDS32_LONGCALL2", /* name */
1108 FALSE, /* partial_inplace */
1109 0xffffffff, /* src_mask */
1110 0xffffffff, /* dst_mask */
1111 FALSE), /* pcrel_offset */
1112
1113 /* Relax hint for conditional call sequence. */
1114 HOWTO2 (R_NDS32_LONGCALL3, /* type */
1115 0, /* rightshift */
1116 2, /* size (0 = byte, 1 = short, 2 = long) */
1117 32, /* bitsize */
1118 FALSE, /* pc_relative */
1119 0, /* bitpos */
1120 complain_overflow_dont,/* complain_on_overflow */
1121 nds32_elf_ignore_reloc,/* special_function */
1122 "R_NDS32_LONGCALL3", /* name */
1123 FALSE, /* partial_inplace */
1124 0xffffffff, /* src_mask */
1125 0xffffffff, /* dst_mask */
1126 FALSE), /* pcrel_offset */
1127
1128 /* Relax hint for unconditional branch sequence. */
1129 HOWTO2 (R_NDS32_LONGJUMP1, /* type */
1130 0, /* rightshift */
1131 2, /* size (0 = byte, 1 = short, 2 = long) */
1132 32, /* bitsize */
1133 FALSE, /* pc_relative */
1134 0, /* bitpos */
1135 complain_overflow_dont,/* complain_on_overflow */
1136 nds32_elf_ignore_reloc,/* special_function */
1137 "R_NDS32_LONGJUMP1", /* name */
1138 FALSE, /* partial_inplace */
1139 0xffffffff, /* src_mask */
1140 0xffffffff, /* dst_mask */
1141 FALSE), /* pcrel_offset */
1142
1143 /* Relax hint for conditional branch sequence. */
1144 HOWTO2 (R_NDS32_LONGJUMP2, /* type */
1145 0, /* rightshift */
1146 2, /* size (0 = byte, 1 = short, 2 = long) */
1147 32, /* bitsize */
1148 FALSE, /* pc_relative */
1149 0, /* bitpos */
1150 complain_overflow_dont,/* complain_on_overflow */
1151 nds32_elf_ignore_reloc,/* special_function */
1152 "R_NDS32_LONGJUMP2", /* name */
1153 FALSE, /* partial_inplace */
1154 0xffffffff, /* src_mask */
1155 0xffffffff, /* dst_mask */
1156 FALSE), /* pcrel_offset */
1157
1158 /* Relax hint for conditional branch sequence. */
1159 HOWTO2 (R_NDS32_LONGJUMP3, /* type */
1160 0, /* rightshift */
1161 2, /* size (0 = byte, 1 = short, 2 = long) */
1162 32, /* bitsize */
1163 FALSE, /* pc_relative */
1164 0, /* bitpos */
1165 complain_overflow_dont,/* complain_on_overflow */
1166 nds32_elf_ignore_reloc,/* special_function */
1167 "R_NDS32_LONGJUMP3", /* name */
1168 FALSE, /* partial_inplace */
1169 0xffffffff, /* src_mask */
1170 0xffffffff, /* dst_mask */
1171 FALSE), /* pcrel_offset */
1172
1173 /* Relax hint for load/store sequence. */
1174 HOWTO2 (R_NDS32_LOADSTORE, /* type */
1175 0, /* rightshift */
1176 2, /* size (0 = byte, 1 = short, 2 = long) */
1177 32, /* bitsize */
1178 FALSE, /* pc_relative */
1179 0, /* bitpos */
1180 complain_overflow_dont,/* complain_on_overflow */
1181 nds32_elf_ignore_reloc,/* special_function */
1182 "R_NDS32_LOADSTORE", /* name */
1183 FALSE, /* partial_inplace */
1184 0xffffffff, /* src_mask */
1185 0xffffffff, /* dst_mask */
1186 FALSE), /* pcrel_offset */
1187
1188 /* Relax hint for load/store sequence. */
1189 HOWTO2 (R_NDS32_9_FIXED_RELA, /* type */
1190 0, /* rightshift */
1191 1, /* size (0 = byte, 1 = short, 2 = long) */
1192 16, /* bitsize */
1193 FALSE, /* pc_relative */
1194 0, /* bitpos */
1195 complain_overflow_dont,/* complain_on_overflow */
1196 nds32_elf_ignore_reloc,/* special_function */
1197 "R_NDS32_9_FIXED_RELA",/* name */
1198 FALSE, /* partial_inplace */
1199 0x000000ff, /* src_mask */
1200 0x000000ff, /* dst_mask */
1201 FALSE), /* pcrel_offset */
1202
1203 /* Relax hint for load/store sequence. */
1204 HOWTO2 (R_NDS32_15_FIXED_RELA,/* type */
1205 0, /* rightshift */
1206 2, /* size (0 = byte, 1 = short, 2 = long) */
1207 32, /* bitsize */
1208 FALSE, /* pc_relative */
1209 0, /* bitpos */
1210 complain_overflow_dont,/* complain_on_overflow */
1211 nds32_elf_ignore_reloc,/* special_function */
1212 "R_NDS32_15_FIXED_RELA",/* name */
1213 FALSE, /* partial_inplace */
1214 0x00003fff, /* src_mask */
1215 0x00003fff, /* dst_mask */
1216 FALSE), /* pcrel_offset */
1217
1218 /* Relax hint for load/store sequence. */
1219 HOWTO2 (R_NDS32_17_FIXED_RELA,/* type */
1220 0, /* rightshift */
1221 2, /* size (0 = byte, 1 = short, 2 = long) */
1222 32, /* bitsize */
1223 FALSE, /* pc_relative */
1224 0, /* bitpos */
1225 complain_overflow_dont,/* complain_on_overflow */
1226 nds32_elf_ignore_reloc,/* special_function */
1227 "R_NDS32_17_FIXED_RELA",/* name */
1228 FALSE, /* partial_inplace */
1229 0x0000ffff, /* src_mask */
1230 0x0000ffff, /* dst_mask */
1231 FALSE), /* pcrel_offset */
1232
1233 /* Relax hint for load/store sequence. */
1234 HOWTO2 (R_NDS32_25_FIXED_RELA,/* type */
1235 0, /* rightshift */
1236 2, /* size (0 = byte, 1 = short, 2 = long) */
1237 32, /* bitsize */
1238 FALSE, /* pc_relative */
1239 0, /* bitpos */
1240 complain_overflow_dont,/* complain_on_overflow */
1241 nds32_elf_ignore_reloc,/* special_function */
1242 "R_NDS32_25_FIXED_RELA",/* name */
1243 FALSE, /* partial_inplace */
1244 0x00ffffff, /* src_mask */
1245 0x00ffffff, /* dst_mask */
1246 FALSE), /* pcrel_offset */
1247
1248 /* High 20 bits of PLT symbol offset relative to PC. */
1249 HOWTO2 (R_NDS32_PLTREL_HI20, /* type */
1250 12, /* rightshift */
1251 2, /* size (0 = byte, 1 = short, 2 = long) */
1252 20, /* bitsize */
1253 FALSE, /* pc_relative */
1254 0, /* bitpos */
1255 complain_overflow_dont,/* complain_on_overflow */
1256 bfd_elf_generic_reloc, /* special_function */
1257 "R_NDS32_PLTREL_HI20", /* name */
1258 FALSE, /* partial_inplace */
1259 0x000fffff, /* src_mask */
1260 0x000fffff, /* dst_mask */
1261 FALSE), /* pcrel_offset */
1262
1263 /* Low 12 bits of PLT symbol offset relative to PC. */
1264 HOWTO2 (R_NDS32_PLTREL_LO12, /* type */
1265 0, /* rightshift */
1266 2, /* size (0 = byte, 1 = short, 2 = long) */
1267 12, /* bitsize */
1268 FALSE, /* pc_relative */
1269 0, /* bitpos */
1270 complain_overflow_dont,/* complain_on_overflow */
1271 bfd_elf_generic_reloc, /* special_function */
1272 "R_NDS32_PLTREL_LO12", /* name */
1273 FALSE, /* partial_inplace */
1274 0x00000fff, /* src_mask */
1275 0x00000fff, /* dst_mask */
1276 FALSE), /* pcrel_offset */
1277
1278 /* High 20 bits of PLT symbol offset relative to GOT (GP). */
1279 HOWTO2 (R_NDS32_PLT_GOTREL_HI20, /* type */
1280 12, /* rightshift */
1281 2, /* size (0 = byte, 1 = short, 2 = long) */
1282 20, /* bitsize */
1283 FALSE, /* pc_relative */
1284 0, /* bitpos */
1285 complain_overflow_dont,/* complain_on_overflow */
1286 bfd_elf_generic_reloc, /* special_function */
1287 "R_NDS32_PLT_GOTREL_HI20",/* name */
1288 FALSE, /* partial_inplace */
1289 0x000fffff, /* src_mask */
1290 0x000fffff, /* dst_mask */
1291 FALSE), /* pcrel_offset */
1292
1293 /* Low 12 bits of PLT symbol offset relative to GOT (GP). */
1294 HOWTO2 (R_NDS32_PLT_GOTREL_LO12,/* type */
1295 0, /* rightshift */
1296 2, /* size (0 = byte, 1 = short, 2 = long) */
1297 12, /* bitsize */
1298 FALSE, /* pc_relative */
1299 0, /* bitpos */
1300 complain_overflow_dont,/* complain_on_overflow */
1301 bfd_elf_generic_reloc, /* special_function */
1302 "R_NDS32_PLT_GOTREL_LO12",/* name */
1303 FALSE, /* partial_inplace */
1304 0x00000fff, /* src_mask */
1305 0x00000fff, /* dst_mask */
1306 FALSE), /* pcrel_offset */
1307
1308 /* Small data area 12 bits offset. */
1309 HOWTO2 (R_NDS32_SDA12S2_DP_RELA,/* type */
1310 2, /* rightshift */
1311 2, /* size (0 = byte, 1 = short, 2 = long) */
1312 12, /* bitsize */
1313 FALSE, /* pc_relative */
1314 0, /* bitpos */
1315 complain_overflow_signed,/* complain_on_overflow */
1316 bfd_elf_generic_reloc, /* special_function */
1317 "R_NDS32_SDA12S2_DP_RELA",/* name */
1318 FALSE, /* partial_inplace */
1319 0x00000fff, /* src_mask */
1320 0x00000fff, /* dst_mask */
1321 FALSE), /* pcrel_offset */
1322
1323 /* Small data area 12 bits offset. */
1324 HOWTO2 (R_NDS32_SDA12S2_SP_RELA,/* type */
1325 2, /* rightshift */
1326 2, /* size (0 = byte, 1 = short, 2 = long) */
1327 12, /* bitsize */
1328 FALSE, /* pc_relative */
1329 0, /* bitpos */
1330 complain_overflow_signed,/* complain_on_overflow */
1331 bfd_elf_generic_reloc, /* special_function */
1332 "R_NDS32_SDA12S2_SP_RELA",/* name */
1333 FALSE, /* partial_inplace */
1334 0x00000fff, /* src_mask */
1335 0x00000fff, /* dst_mask */
1336 FALSE), /* pcrel_offset */
1337 /* Lower 12 bits of address. */
1338
1339 HOWTO2 (R_NDS32_LO12S2_DP_RELA, /* type */
1340 2, /* rightshift */
1341 2, /* size (0 = byte, 1 = short, 2 = long) */
1342 10, /* bitsize */
1343 FALSE, /* pc_relative */
1344 0, /* bitpos */
1345 complain_overflow_dont,/* complain_on_overflow */
1346 bfd_elf_generic_reloc, /* special_function */
1347 "R_NDS32_LO12S2_DP_RELA",/* name */
1348 FALSE, /* partial_inplace */
1349 0x000003ff, /* src_mask */
1350 0x000003ff, /* dst_mask */
1351 FALSE), /* pcrel_offset */
1352
1353 /* Lower 12 bits of address. */
1354 HOWTO2 (R_NDS32_LO12S2_SP_RELA,/* type */
1355 2, /* rightshift */
1356 2, /* size (0 = byte, 1 = short, 2 = long) */
1357 10, /* bitsize */
1358 FALSE, /* pc_relative */
1359 0, /* bitpos */
1360 complain_overflow_dont,/* complain_on_overflow */
1361 bfd_elf_generic_reloc, /* special_function */
1362 "R_NDS32_LO12S2_SP_RELA",/* name */
1363 FALSE, /* partial_inplace */
1364 0x000003ff, /* src_mask */
1365 0x000003ff, /* dst_mask */
1366 FALSE), /* pcrel_offset */
1367 /* Lower 12 bits of address. Special identity for or case. */
1368 HOWTO2 (R_NDS32_LO12S0_ORI_RELA,/* type */
1369 0, /* rightshift */
1370 2, /* size (0 = byte, 1 = short, 2 = long) */
1371 12, /* bitsize */
1372 FALSE, /* pc_relative */
1373 0, /* bitpos */
1374 complain_overflow_dont,/* complain_on_overflow */
1375 bfd_elf_generic_reloc, /* special_function */
1376 "R_NDS32_LO12S0_ORI_RELA",/* name */
1377 FALSE, /* partial_inplace */
1378 0x00000fff, /* src_mask */
1379 0x00000fff, /* dst_mask */
1380 FALSE), /* pcrel_offset */
1381 /* Small data area 19 bits offset. */
1382 HOWTO2 (R_NDS32_SDA16S3_RELA, /* type */
1383 3, /* rightshift */
1384 2, /* size (0 = byte, 1 = short, 2 = long) */
1385 16, /* bitsize */
1386 FALSE, /* pc_relative */
1387 0, /* bitpos */
1388 complain_overflow_signed,/* complain_on_overflow */
1389 bfd_elf_generic_reloc, /* special_function */
1390 "R_NDS32_SDA16S3_RELA",/* name */
1391 FALSE, /* partial_inplace */
1392 0x0000ffff, /* src_mask */
1393 0x0000ffff, /* dst_mask */
1394 FALSE), /* pcrel_offset */
1395
1396 /* Small data area 15 bits offset. */
1397 HOWTO2 (R_NDS32_SDA17S2_RELA, /* type */
1398 2, /* rightshift */
1399 2, /* size (0 = byte, 1 = short, 2 = long) */
1400 17, /* bitsize */
1401 FALSE, /* pc_relative */
1402 0, /* bitpos */
1403 complain_overflow_signed,/* complain_on_overflow */
1404 bfd_elf_generic_reloc, /* special_function */
1405 "R_NDS32_SDA17S2_RELA",/* name */
1406 FALSE, /* partial_inplace */
1407 0x0001ffff, /* src_mask */
1408 0x0001ffff, /* dst_mask */
1409 FALSE), /* pcrel_offset */
1410
1411 HOWTO2 (R_NDS32_SDA18S1_RELA, /* type */
1412 1, /* rightshift */
1413 2, /* size (0 = byte, 1 = short, 2 = long) */
1414 18, /* bitsize */
1415 FALSE, /* pc_relative */
1416 0, /* bitpos */
1417 complain_overflow_signed,/* complain_on_overflow */
1418 bfd_elf_generic_reloc, /* special_function */
1419 "R_NDS32_SDA18S1_RELA",/* name */
1420 FALSE, /* partial_inplace */
1421 0x0003ffff, /* src_mask */
1422 0x0003ffff, /* dst_mask */
1423 FALSE), /* pcrel_offset */
1424
1425 HOWTO2 (R_NDS32_SDA19S0_RELA, /* type */
1426 0, /* rightshift */
1427 2, /* size (0 = byte, 1 = short, 2 = long) */
1428 19, /* bitsize */
1429 FALSE, /* pc_relative */
1430 0, /* bitpos */
1431 complain_overflow_signed,/* complain_on_overflow */
1432 bfd_elf_generic_reloc, /* special_function */
1433 "R_NDS32_SDA19S0_RELA",/* name */
1434 FALSE, /* partial_inplace */
1435 0x0007ffff, /* src_mask */
1436 0x0007ffff, /* dst_mask */
1437 FALSE), /* pcrel_offset */
1438 HOWTO2 (R_NDS32_DWARF2_OP1_RELA,/* type */
1439 0, /* rightshift */
1440 0, /* size (0 = byte, 1 = short, 2 = long) */
1441 8, /* bitsize */
1442 FALSE, /* pc_relative */
1443 0, /* bitpos */
1444 complain_overflow_dont,/* complain_on_overflow */
1445 nds32_elf_ignore_reloc,/* special_function */
1446 "R_NDS32_DWARF2_OP1_RELA",/* name */
1447 FALSE, /* partial_inplace */
1448 0xff, /* src_mask */
1449 0xff, /* dst_mask */
1450 FALSE), /* pcrel_offset */
1451 HOWTO2 (R_NDS32_DWARF2_OP2_RELA,/* type */
1452 0, /* rightshift */
1453 1, /* size (0 = byte, 1 = short, 2 = long) */
1454 16, /* bitsize */
1455 FALSE, /* pc_relative */
1456 0, /* bitpos */
1457 complain_overflow_dont,/* complain_on_overflow */
1458 nds32_elf_ignore_reloc,/* special_function */
1459 "R_NDS32_DWARF2_OP2_RELA",/* name */
1460 FALSE, /* partial_inplace */
1461 0xffff, /* src_mask */
1462 0xffff, /* dst_mask */
1463 FALSE), /* pcrel_offset */
1464 HOWTO2 (R_NDS32_DWARF2_LEB_RELA,/* type */
1465 0, /* rightshift */
1466 2, /* size (0 = byte, 1 = short, 2 = long) */
1467 32, /* bitsize */
1468 FALSE, /* pc_relative */
1469 0, /* bitpos */
1470 complain_overflow_dont,/* complain_on_overflow */
1471 nds32_elf_ignore_reloc,/* special_function */
1472 "R_NDS32_DWARF2_LEB_RELA",/* name */
1473 FALSE, /* partial_inplace */
1474 0xffffffff, /* src_mask */
1475 0xffffffff, /* dst_mask */
1476 FALSE), /* pcrel_offset */
1477 HOWTO2 (R_NDS32_UPDATE_TA_RELA,/* type */
1478 0, /* rightshift */
1479 1, /* size (0 = byte, 1 = short, 2 = long) */
1480 16, /* bitsize */
1481 FALSE, /* pc_relative */
1482 0, /* bitpos */
1483 complain_overflow_dont,/* complain_on_overflow */
1484 nds32_elf_ignore_reloc,/* special_function */
1485 "R_NDS32_UPDATE_TA_RELA",/* name */
1486 FALSE, /* partial_inplace */
1487 0xffff, /* src_mask */
1488 0xffff, /* dst_mask */
1489 FALSE), /* pcrel_offset */
1490 /* Like R_NDS32_PCREL, but referring to the procedure linkage table
1491 entry for the symbol. */
1492 HOWTO2 (R_NDS32_9_PLTREL, /* type */
1493 1, /* rightshift */
1494 1, /* size (0 = byte, 1 = short, 2 = long) */
1495 8, /* bitsize */
1496 TRUE, /* pc_relative */
1497 0, /* bitpos */
1498 complain_overflow_signed,/* complain_on_overflow */
1499 bfd_elf_generic_reloc, /* special_function */
1500 "R_NDS32_9_PLTREL", /* name */
1501 FALSE, /* partial_inplace */
1502 0xff, /* src_mask */
1503 0xff, /* dst_mask */
1504 TRUE), /* pcrel_offset */
1505 /* Low 20 bits of PLT symbol offset relative to GOT (GP). */
1506 HOWTO2 (R_NDS32_PLT_GOTREL_LO20,/* type */
1507 0, /* rightshift */
1508 2, /* size (0 = byte, 1 = short, 2 = long) */
1509 20, /* bitsize */
1510 FALSE, /* pc_relative */
1511 0, /* bitpos */
1512 complain_overflow_dont,/* complain_on_overflow */
1513 bfd_elf_generic_reloc, /* special_function */
1514 "R_NDS32_PLT_GOTREL_LO20",/* name */
1515 FALSE, /* partial_inplace */
1516 0x000fffff, /* src_mask */
1517 0x000fffff, /* dst_mask */
1518 FALSE), /* pcrel_offset */
1519 /* low 15 bits of PLT symbol offset relative to GOT (GP) */
1520 HOWTO2 (R_NDS32_PLT_GOTREL_LO15,/* type */
1521 0, /* rightshift */
1522 2, /* size (0 = byte, 1 = short, 2 = long) */
1523 15, /* bitsize */
1524 FALSE, /* pc_relative */
1525 0, /* bitpos */
1526 complain_overflow_dont,/* complain_on_overflow */
1527 bfd_elf_generic_reloc, /* special_function */
1528 "R_NDS32_PLT_GOTREL_LO15",/* name */
1529 FALSE, /* partial_inplace */
1530 0x00007fff, /* src_mask */
1531 0x00007fff, /* dst_mask */
1532 FALSE), /* pcrel_offset */
1533 /* Low 19 bits of PLT symbol offset relative to GOT (GP). */
1534 HOWTO2 (R_NDS32_PLT_GOTREL_LO19,/* type */
1535 0, /* rightshift */
1536 2, /* size (0 = byte, 1 = short, 2 = long) */
1537 19, /* bitsize */
1538 FALSE, /* pc_relative */
1539 0, /* bitpos */
1540 complain_overflow_dont,/* complain_on_overflow */
1541 bfd_elf_generic_reloc, /* special_function */
1542 "R_NDS32_PLT_GOTREL_LO19",/* name */
1543 FALSE, /* partial_inplace */
1544 0x0007ffff, /* src_mask */
1545 0x0007ffff, /* dst_mask */
1546 FALSE), /* pcrel_offset */
1547 HOWTO2 (R_NDS32_GOT_LO15, /* type */
1548 0, /* rightshift */
1549 2, /* size (0 = byte, 1 = short, 2 = long) */
1550 15, /* bitsize */
1551 FALSE, /* pc_relative */
1552 0, /* bitpos */
1553 complain_overflow_dont,/* complain_on_overflow */
1554 bfd_elf_generic_reloc, /* special_function */
1555 "R_NDS32_GOT_LO15", /* name */
1556 FALSE, /* partial_inplace */
1557 0x00007fff, /* src_mask */
1558 0x00007fff, /* dst_mask */
1559 FALSE), /* pcrel_offset */
1560 HOWTO2 (R_NDS32_GOT_LO19, /* type */
1561 0, /* rightshift */
1562 2, /* size (0 = byte, 1 = short, 2 = long) */
1563 19, /* bitsize */
1564 FALSE, /* pc_relative */
1565 0, /* bitpos */
1566 complain_overflow_dont,/* complain_on_overflow */
1567 bfd_elf_generic_reloc, /* special_function */
1568 "R_NDS32_GOT_LO19", /* name */
1569 FALSE, /* partial_inplace */
1570 0x0007ffff, /* src_mask */
1571 0x0007ffff, /* dst_mask */
1572 FALSE), /* pcrel_offset */
1573 HOWTO2 (R_NDS32_GOTOFF_LO15, /* type */
1574 0, /* rightshift */
1575 2, /* size (0 = byte, 1 = short, 2 = long) */
1576 15, /* bitsize */
1577 FALSE, /* pc_relative */
1578 0, /* bitpos */
1579 complain_overflow_dont,/* complain_on_overflow */
1580 bfd_elf_generic_reloc, /* special_function */
1581 "R_NDS32_GOTOFF_LO15", /* name */
1582 FALSE, /* partial_inplace */
1583 0x00007fff, /* src_mask */
1584 0x00007fff, /* dst_mask */
1585 FALSE), /* pcrel_offset */
1586 HOWTO2 (R_NDS32_GOTOFF_LO19, /* type */
1587 0, /* rightshift */
1588 2, /* size (0 = byte, 1 = short, 2 = long) */
1589 19, /* bitsize */
1590 FALSE, /* pc_relative */
1591 0, /* bitpos */
1592 complain_overflow_dont,/* complain_on_overflow */
1593 bfd_elf_generic_reloc, /* special_function */
1594 "R_NDS32_GOTOFF_LO19", /* name */
1595 FALSE, /* partial_inplace */
1596 0x0007ffff, /* src_mask */
1597 0x0007ffff, /* dst_mask */
1598 FALSE), /* pcrel_offset */
1599 /* GOT 15 bits offset. */
1600 HOWTO2 (R_NDS32_GOT15S2_RELA, /* type */
1601 2, /* rightshift */
1602 2, /* size (0 = byte, 1 = short, 2 = long) */
1603 15, /* bitsize */
1604 FALSE, /* pc_relative */
1605 0, /* bitpos */
1606 complain_overflow_signed,/* complain_on_overflow */
1607 bfd_elf_generic_reloc, /* special_function */
1608 "R_NDS32_GOT15S2_RELA",/* name */
1609 FALSE, /* partial_inplace */
1610 0x00007fff, /* src_mask */
1611 0x00007fff, /* dst_mask */
1612 FALSE), /* pcrel_offset */
1613 /* GOT 17 bits offset. */
1614 HOWTO2 (R_NDS32_GOT17S2_RELA, /* type */
1615 2, /* rightshift */
1616 2, /* size (0 = byte, 1 = short, 2 = long) */
1617 17, /* bitsize */
1618 FALSE, /* pc_relative */
1619 0, /* bitpos */
1620 complain_overflow_signed,/* complain_on_overflow */
1621 bfd_elf_generic_reloc, /* special_function */
1622 "R_NDS32_GOT17S2_RELA",/* name */
1623 FALSE, /* partial_inplace */
1624 0x0001ffff, /* src_mask */
1625 0x0001ffff, /* dst_mask */
1626 FALSE), /* pcrel_offset */
1627 /* A 5 bit address. */
1628 HOWTO2 (R_NDS32_5_RELA, /* type */
1629 0, /* rightshift */
1630 1, /* size (0 = byte, 1 = short, 2 = long) */
1631 5, /* bitsize */
1632 FALSE, /* pc_relative */
1633 0, /* bitpos */
1634 complain_overflow_signed,/* complain_on_overflow */
1635 bfd_elf_generic_reloc, /* special_function */
1636 "R_NDS32_5_RELA", /* name */
1637 FALSE, /* partial_inplace */
1638 0x1f, /* src_mask */
1639 0x1f, /* dst_mask */
1640 FALSE), /* pcrel_offset */
1641 HOWTO2 (R_NDS32_10_UPCREL_RELA,/* type */
1642 1, /* rightshift */
1643 1, /* size (0 = byte, 1 = short, 2 = long) */
1644 9, /* bitsize */
1645 TRUE, /* pc_relative */
1646 0, /* bitpos */
1647 complain_overflow_unsigned,/* complain_on_overflow */
1648 bfd_elf_generic_reloc, /* special_function */
1649 "R_NDS32_10_UPCREL_RELA",/* name */
1650 FALSE, /* partial_inplace */
1651 0x1ff, /* src_mask */
1652 0x1ff, /* dst_mask */
1653 TRUE), /* pcrel_offset */
1654 HOWTO2 (R_NDS32_SDA_FP7U2_RELA,/* type */
1655 2, /* rightshift */
1656 1, /* size (0 = byte, 1 = short, 2 = long) */
1657 7, /* bitsize */
1658 FALSE, /* pc_relative */
1659 0, /* bitpos */
1660 complain_overflow_unsigned,/* complain_on_overflow */
1661 bfd_elf_generic_reloc, /* special_function */
1662 "R_NDS32_SDA_FP7U2_RELA",/* name */
1663 FALSE, /* partial_inplace */
1664 0x0000007f, /* src_mask */
1665 0x0000007f, /* dst_mask */
1666 FALSE), /* pcrel_offset */
1667 HOWTO2 (R_NDS32_WORD_9_PCREL_RELA,/* type */
1668 1, /* rightshift */
1669 2, /* size (0 = byte, 1 = short, 2 = long) */
1670 8, /* bitsize */
1671 TRUE, /* pc_relative */
1672 0, /* bitpos */
1673 complain_overflow_signed,/* complain_on_overflow */
1674 bfd_elf_generic_reloc, /* special_function */
1675 "R_NDS32_WORD_9_PCREL_RELA",/* name */
1676 FALSE, /* partial_inplace */
1677 0xff, /* src_mask */
1678 0xff, /* dst_mask */
1679 TRUE), /* pcrel_offset */
1680 HOWTO2 (R_NDS32_25_ABS_RELA, /* type */
1681 1, /* rightshift */
1682 2, /* size (0 = byte, 1 = short, 2 = long) */
1683 24, /* bitsize */
1684 FALSE, /* pc_relative */
1685 0, /* bitpos */
1686 complain_overflow_dont,/* complain_on_overflow */
1687 bfd_elf_generic_reloc, /* special_function */
1688 "R_NDS32_25_ABS_RELA", /* name */
1689 FALSE, /* partial_inplace */
1690 0xffffff, /* src_mask */
1691 0xffffff, /* dst_mask */
1692 FALSE), /* pcrel_offset */
1693
1694 /* A relative 17 bit relocation for ifc, right shifted by 1. */
1695 HOWTO2 (R_NDS32_17IFC_PCREL_RELA,/* type */
1696 1, /* rightshift */
1697 2, /* size (0 = byte, 1 = short, 2 = long) */
1698 16, /* bitsize */
1699 TRUE, /* pc_relative */
1700 0, /* bitpos */
1701 complain_overflow_signed,/* complain_on_overflow */
1702 bfd_elf_generic_reloc, /* special_function */
1703 "R_NDS32_17IFC_PCREL_RELA",/* name */
1704 FALSE, /* partial_inplace */
1705 0xffff, /* src_mask */
1706 0xffff, /* dst_mask */
1707 TRUE), /* pcrel_offset */
1708
1709 /* A relative unsigned 10 bit relocation for ifc, right shifted by 1. */
1710 HOWTO2 (R_NDS32_10IFCU_PCREL_RELA,/* type */
1711 1, /* rightshift */
1712 1, /* size (0 = byte, 1 = short, 2 = long) */
1713 9, /* bitsize */
1714 TRUE, /* pc_relative */
1715 0, /* bitpos */
1716 complain_overflow_unsigned,/* complain_on_overflow */
1717 bfd_elf_generic_reloc, /* special_function */
1718 "R_NDS32_10IFCU_PCREL_RELA",/* name */
1719 FALSE, /* partial_inplace */
1720 0x1ff, /* src_mask */
1721 0x1ff, /* dst_mask */
1722 TRUE), /* pcrel_offset */
1723
1724 /* Like R_NDS32_HI20, but referring to the TLS LE entry for the symbol. */
1725 HOWTO2 (R_NDS32_TLS_LE_HI20, /* type */
1726 12, /* rightshift */
1727 2, /* size (0 = byte, 1 = short, 2 = long) */
1728 20, /* bitsize */
1729 FALSE, /* pc_relative */
1730 0, /* bitpos */
1731 complain_overflow_dont,/* complain_on_overflow */
1732 bfd_elf_generic_reloc, /* special_function */
1733 "R_NDS32_TLS_LE_HI20", /* name */
1734 FALSE, /* partial_inplace */
1735 0x000fffff, /* src_mask */
1736 0x000fffff, /* dst_mask */
1737 FALSE), /* pcrel_offset */
1738
1739 HOWTO2 (R_NDS32_TLS_LE_LO12, /* type */
1740 0, /* rightshift */
1741 2, /* size (0 = byte, 1 = short, 2 = long) */
1742 12, /* bitsize */
1743 FALSE, /* pc_relative */
1744 0, /* bitpos */
1745 complain_overflow_dont,/* complain_on_overflow */
1746 bfd_elf_generic_reloc, /* special_function */
1747 "R_NDS32_TLS_LE_LO12", /* name */
1748 FALSE, /* partial_inplace */
1749 0x00000fff, /* src_mask */
1750 0x00000fff, /* dst_mask */
1751 FALSE), /* pcrel_offset */
1752
1753 /* Like R_NDS32_HI20, but referring to the TLS IE entry for the symbol. */
1754 HOWTO2 (R_NDS32_TLS_IE_HI20, /* type */
1755 12, /* rightshift */
1756 2, /* size (0 = byte, 1 = short, 2 = long) */
1757 20, /* bitsize */
1758 FALSE, /* pc_relative */
1759 0, /* bitpos */
1760 complain_overflow_dont,/* complain_on_overflow */
1761 bfd_elf_generic_reloc, /* special_function */
1762 "R_NDS32_TLS_IE_HI20", /* name */
1763 FALSE, /* partial_inplace */
1764 0x000fffff, /* src_mask */
1765 0x000fffff, /* dst_mask */
1766 FALSE), /* pcrel_offset */
1767
1768 HOWTO2 (R_NDS32_TLS_IE_LO12S2,/* type */
1769 2, /* rightshift */
1770 2, /* size (0 = byte, 1 = short, 2 = long) */
1771 10, /* bitsize */
1772 FALSE, /* pc_relative */
1773 0, /* bitpos */
1774 complain_overflow_dont,/* complain_on_overflow */
1775 bfd_elf_generic_reloc, /* special_function */
1776 "R_NDS32_TLS_IE_LO12S2",/* name */
1777 FALSE, /* partial_inplace */
1778 0x000003ff, /* src_mask */
1779 0x000003ff, /* dst_mask */
1780 FALSE), /* pcrel_offset */
1781
1782 /* TLS LE TP offset relocation */
1783 HOWTO2 (R_NDS32_TLS_TPOFF, /* type */
1784 0, /* rightshift */
1785 2, /* size (0 = byte, 1 = short, 2 = long) */
1786 32, /* bitsize */
1787 FALSE, /* pc_relative */
1788 0, /* bitpos */
1789 complain_overflow_bitfield,/* complain_on_overflow */
1790 bfd_elf_generic_reloc, /* special_function */
1791 "R_NDS32_TLS_TPOFF", /* name */
1792 FALSE, /* partial_inplace */
1793 0xffffffff, /* src_mask */
1794 0xffffffff, /* dst_mask */
1795 FALSE), /* pcrel_offset */
1796
1797 /* A 20 bit address. */
1798 HOWTO2 (R_NDS32_TLS_LE_20, /* type */
1799 0, /* rightshift */
1800 2, /* size (0 = byte, 1 = short, 2 = long) */
1801 20, /* bitsize */
1802 FALSE, /* pc_relative */
1803 0, /* bitpos */
1804 complain_overflow_signed,/* complain_on_overflow */
1805 bfd_elf_generic_reloc, /* special_function */
1806 "R_NDS32_TLS_LE_20", /* name */
1807 FALSE, /* partial_inplace */
1808 0xfffff, /* src_mask */
1809 0xfffff, /* dst_mask */
1810 FALSE), /* pcrel_offset */
1811
1812 HOWTO2 (R_NDS32_TLS_LE_15S0, /* type */
1813 0, /* rightshift */
1814 2, /* size (0 = byte, 1 = short, 2 = long) */
1815 15, /* bitsize */
1816 FALSE, /* pc_relative */
1817 0, /* bitpos */
1818 complain_overflow_signed,/* complain_on_overflow */
1819 bfd_elf_generic_reloc, /* special_function */
1820 "R_NDS32_TLS_LE_15S0", /* name */
1821 FALSE, /* partial_inplace */
1822 0x7fff, /* src_mask */
1823 0x7fff, /* dst_mask */
1824 FALSE), /* pcrel_offset */
1825 HOWTO2 (R_NDS32_TLS_LE_15S1, /* type */
1826 1, /* rightshift */
1827 2, /* size (0 = byte, 1 = short, 2 = long) */
1828 15, /* bitsize */
1829 FALSE, /* pc_relative */
1830 0, /* bitpos */
1831 complain_overflow_signed,/* complain_on_overflow */
1832 bfd_elf_generic_reloc, /* special_function */
1833 "R_NDS32_TLS_LE_15S1", /* name */
1834 FALSE, /* partial_inplace */
1835 0x7fff, /* src_mask */
1836 0x7fff, /* dst_mask */
1837 FALSE), /* pcrel_offset */
1838 HOWTO2 (R_NDS32_TLS_LE_15S2, /* type */
1839 2, /* rightshift */
1840 2, /* size (0 = byte, 1 = short, 2 = long) */
1841 15, /* bitsize */
1842 FALSE, /* pc_relative */
1843 0, /* bitpos */
1844 complain_overflow_signed,/* complain_on_overflow */
1845 bfd_elf_generic_reloc, /* special_function */
1846 "R_NDS32_TLS_LE_15S2", /* name */
1847 FALSE, /* partial_inplace */
1848 0x7fff, /* src_mask */
1849 0x7fff, /* dst_mask */
1850 FALSE), /* pcrel_offset */
1851
1852 /* Relax hint for unconditional call sequence */
1853 HOWTO2 (R_NDS32_LONGCALL4, /* type */
1854 0, /* rightshift */
1855 2, /* size (0 = byte, 1 = short, 2 = long) */
1856 32, /* bitsize */
1857 FALSE, /* pc_relative */
1858 0, /* bitpos */
1859 complain_overflow_dont,/* complain_on_overflow */
1860 nds32_elf_ignore_reloc,/* special_function */
1861 "R_NDS32_LONGCALL4", /* name */
1862 FALSE, /* partial_inplace */
1863 0xffffffff, /* src_mask */
1864 0xffffffff, /* dst_mask */
1865 FALSE), /* pcrel_offset */
1866
1867 /* Relax hint for conditional call sequence. */
1868 HOWTO2 (R_NDS32_LONGCALL5, /* type */
1869 0, /* rightshift */
1870 2, /* size (0 = byte, 1 = short, 2 = long) */
1871 32, /* bitsize */
1872 FALSE, /* pc_relative */
1873 0, /* bitpos */
1874 complain_overflow_dont,/* complain_on_overflow */
1875 nds32_elf_ignore_reloc,/* special_function */
1876 "R_NDS32_LONGCALL5", /* name */
1877 FALSE, /* partial_inplace */
1878 0xffffffff, /* src_mask */
1879 0xffffffff, /* dst_mask */
1880 FALSE), /* pcrel_offset */
1881
1882 /* Relax hint for conditional call sequence. */
1883 HOWTO2 (R_NDS32_LONGCALL6, /* type */
1884 0, /* rightshift */
1885 2, /* size (0 = byte, 1 = short, 2 = long) */
1886 32, /* bitsize */
1887 FALSE, /* pc_relative */
1888 0, /* bitpos */
1889 complain_overflow_dont,/* complain_on_overflow */
1890 nds32_elf_ignore_reloc,/* special_function */
1891 "R_NDS32_LONGCALL6", /* name */
1892 FALSE, /* partial_inplace */
1893 0xffffffff, /* src_mask */
1894 0xffffffff, /* dst_mask */
1895 FALSE), /* pcrel_offset */
1896
1897 /* Relax hint for unconditional branch sequence. */
1898 HOWTO2 (R_NDS32_LONGJUMP4, /* type */
1899 0, /* rightshift */
1900 2, /* size (0 = byte, 1 = short, 2 = long) */
1901 32, /* bitsize */
1902 FALSE, /* pc_relative */
1903 0, /* bitpos */
1904 complain_overflow_dont,/* complain_on_overflow */
1905 nds32_elf_ignore_reloc,/* special_function */
1906 "R_NDS32_LONGJUMP4", /* name */
1907 FALSE, /* partial_inplace */
1908 0xffffffff, /* src_mask */
1909 0xffffffff, /* dst_mask */
1910 FALSE), /* pcrel_offset */
1911
1912 /* Relax hint for conditional branch sequence. */
1913 HOWTO2 (R_NDS32_LONGJUMP5, /* type */
1914 0, /* rightshift */
1915 2, /* size (0 = byte, 1 = short, 2 = long) */
1916 32, /* bitsize */
1917 FALSE, /* pc_relative */
1918 0, /* bitpos */
1919 complain_overflow_dont,/* complain_on_overflow */
1920 nds32_elf_ignore_reloc,/* special_function */
1921 "R_NDS32_LONGJUMP5", /* name */
1922 FALSE, /* partial_inplace */
1923 0xffffffff, /* src_mask */
1924 0xffffffff, /* dst_mask */
1925 FALSE), /* pcrel_offset */
1926
1927 /* Relax hint for conditional branch sequence. */
1928 HOWTO2 (R_NDS32_LONGJUMP6, /* type */
1929 0, /* rightshift */
1930 2, /* size (0 = byte, 1 = short, 2 = long) */
1931 32, /* bitsize */
1932 FALSE, /* pc_relative */
1933 0, /* bitpos */
1934 complain_overflow_dont,/* complain_on_overflow */
1935 nds32_elf_ignore_reloc,/* special_function */
1936 "R_NDS32_LONGJUMP6", /* name */
1937 FALSE, /* partial_inplace */
1938 0xffffffff, /* src_mask */
1939 0xffffffff, /* dst_mask */
1940 FALSE), /* pcrel_offset */
1941
1942 /* Relax hint for conditional branch sequence. */
1943 HOWTO2 (R_NDS32_LONGJUMP7, /* type */
1944 0, /* rightshift */
1945 2, /* size (0 = byte, 1 = short, 2 = long) */
1946 32, /* bitsize */
1947 FALSE, /* pc_relative */
1948 0, /* bitpos */
1949 complain_overflow_dont,/* complain_on_overflow */
1950 nds32_elf_ignore_reloc,/* special_function */
1951 "R_NDS32_LONGJUMP7", /* name */
1952 FALSE, /* partial_inplace */
1953 0xffffffff, /* src_mask */
1954 0xffffffff, /* dst_mask */
1955 FALSE), /* pcrel_offset */
1956
1957 HOWTO2 (R_NDS32_TLS_IE_LO12, /* type */
1958 0, /* rightshift */
1959 2, /* size (0 = byte, 1 = short, 2 = long) */
1960 12, /* bitsize */
1961 FALSE, /* pc_relative */
1962 0, /* bitpos */
1963 complain_overflow_dont,/* complain_on_overflow */
1964 bfd_elf_generic_reloc, /* special_function */
1965 "R_NDS32_TLS_IE_LO12", /* name */
1966 FALSE, /* partial_inplace */
1967 0x00000fff, /* src_mask */
1968 0x00000fff, /* dst_mask */
1969 FALSE), /* pcrel_offset */
1970
1971 /* Like R_NDS32_HI20, but referring to the TLS IE (PIE)
1972 entry for the symbol. */
1973 HOWTO2 (R_NDS32_TLS_IEGP_HI20,/* type */
1974 12, /* rightshift */
1975 2, /* size (0 = byte, 1 = short, 2 = long) */
1976 20, /* bitsize */
1977 FALSE, /* pc_relative */
1978 0, /* bitpos */
1979 complain_overflow_dont,/* complain_on_overflow */
1980 bfd_elf_generic_reloc, /* special_function */
1981 "R_NDS32_TLS_IEGP_HI20",/* name */
1982 FALSE, /* partial_inplace */
1983 0x000fffff, /* src_mask */
1984 0x000fffff, /* dst_mask */
1985 FALSE), /* pcrel_offset */
1986
1987 HOWTO2 (R_NDS32_TLS_IEGP_LO12,/* type */
1988 0, /* rightshift */
1989 2, /* size (0 = byte, 1 = short, 2 = long) */
1990 12, /* bitsize */
1991 FALSE, /* pc_relative */
1992 0, /* bitpos */
1993 complain_overflow_dont,/* complain_on_overflow */
1994 bfd_elf_generic_reloc, /* special_function */
1995 "R_NDS32_TLS_IEGP_LO12",/* name */
1996 FALSE, /* partial_inplace */
1997 0x00000fff, /* src_mask */
1998 0x00000fff, /* dst_mask */
1999 FALSE), /* pcrel_offset */
2000
2001 HOWTO2 (R_NDS32_TLS_IEGP_LO12S2,/* type */
2002 2, /* rightshift */
2003 2, /* size (0 = byte, 1 = short, 2 = long) */
2004 10, /* bitsize */
2005 FALSE, /* pc_relative */
2006 0, /* bitpos */
2007 complain_overflow_dont,/* complain_on_overflow */
2008 bfd_elf_generic_reloc, /* special_function */
2009 "R_NDS32_TLS_IEGP_LO12S2",/* name */
2010 FALSE, /* partial_inplace */
2011 0x000003ff, /* src_mask */
2012 0x000003ff, /* dst_mask */
2013 FALSE), /* pcrel_offset */
2014
2015 /* TLS description relocation */
2016 HOWTO2 (R_NDS32_TLS_DESC, /* type */
2017 12, /* rightshift */
2018 2, /* size (0 = byte, 1 = short, 2 = long) */
2019 20, /* bitsize */
2020 FALSE, /* pc_relative */
2021 0, /* bitpos */
2022 complain_overflow_dont,/* complain_on_overflow */
2023 nds32_elf_hi20_reloc, /* special_function */
2024 "R_NDS32_TLS_DESC_HI20",/* name */
2025 FALSE, /* partial_inplace */
2026 0x000fffff, /* src_mask */
2027 0x000fffff, /* dst_mask */
2028 FALSE), /* pcrel_offset */
2029
2030 /* TLS GD/LD description offset high part. */
2031 HOWTO2 (R_NDS32_TLS_DESC_HI20,/* type */
2032 12, /* rightshift */
2033 2, /* size (0 = byte, 1 = short, 2 = long) */
2034 20, /* bitsize */
2035 FALSE, /* pc_relative */
2036 0, /* bitpos */
2037 complain_overflow_dont,/* complain_on_overflow */
2038 nds32_elf_hi20_reloc, /* special_function */
2039 "R_NDS32_TLS_DESC_HI20",/* name */
2040 FALSE, /* partial_inplace */
2041 0x000fffff, /* src_mask */
2042 0x000fffff, /* dst_mask */
2043 FALSE), /* pcrel_offset */
2044
2045 /* TLS GD/LD description offset low part. */
2046 HOWTO2 (R_NDS32_TLS_DESC_LO12,/* type */
2047 0, /* rightshift */
2048 2, /* size (0 = byte, 1 = short, 2 = long) */
2049 12, /* bitsize */
2050 FALSE, /* pc_relative */
2051 0, /* bitpos */
2052 complain_overflow_dont,/* complain_on_overflow */
2053 nds32_elf_lo12_reloc, /* special_function */
2054 "R_NDS32_TLS_DESC_LO12",/* name */
2055 FALSE, /* partial_inplace */
2056 0x00000fff, /* src_mask */
2057 0x00000fff, /* dst_mask */
2058 FALSE), /* pcrel_offset */
2059
2060 /* TLS GD/LD description offset set (movi). */
2061 HOWTO2 (R_NDS32_TLS_DESC_20, /* type */
2062 0, /* rightshift */
2063 2, /* size (0 = byte, 1 = short, 2 = long) */
2064 20, /* bitsize */
2065 FALSE, /* pc_relative */
2066 0, /* bitpos */
2067 complain_overflow_signed,/* complain_on_overflow */
2068 bfd_elf_generic_reloc, /* special_function */
2069 "R_NDS32_TLS_DESC_20", /* name */
2070 FALSE, /* partial_inplace */
2071 0x000fffff, /* src_mask */
2072 0x000fffff, /* dst_mask */
2073 FALSE), /* pcrel_offset */
2074
2075 /* TLS GD/LD description offset set (lwi.gp). */
2076 HOWTO2 (R_NDS32_TLS_DESC_SDA17S2,/* type */
2077 2, /* rightshift */
2078 2, /* size (0 = byte, 1 = short, 2 = long) */
2079 17, /* bitsize */
2080 FALSE, /* pc_relative */
2081 0, /* bitpos */
2082 complain_overflow_signed,/* complain_on_overflow */
2083 bfd_elf_generic_reloc, /* special_function */
2084 "R_NDS32_TLS_DESC_SDA17S2",/* name */
2085 FALSE, /* partial_inplace */
2086 0x0001ffff, /* src_mask */
2087 0x0001ffff, /* dst_mask */
2088 FALSE), /* pcrel_offset */
2089 };
2090
2091 /* Relocations used for relaxation. */
2092 #define HOWTO3(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
2093 [C-R_NDS32_RELAX_ENTRY] = HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC)
2094
2095 static reloc_howto_type nds32_elf_relax_howto_table[] = {
2096 HOWTO3 (R_NDS32_RELAX_ENTRY, /* type */
2097 0, /* rightshift */
2098 2, /* size (0 = byte, 1 = short, 2 = long) */
2099 32, /* bitsize */
2100 FALSE, /* pc_relative */
2101 0, /* bitpos */
2102 complain_overflow_dont,/* complain_on_overflow */
2103 nds32_elf_ignore_reloc,/* special_function */
2104 "R_NDS32_RELAX_ENTRY", /* name */
2105 FALSE, /* partial_inplace */
2106 0xffffffff, /* src_mask */
2107 0xffffffff, /* dst_mask */
2108 FALSE), /* pcrel_offset */
2109 HOWTO3 (R_NDS32_GOT_SUFF, /* type */
2110 0, /* rightshift */
2111 2, /* size (0 = byte, 1 = short, 2 = long) */
2112 32, /* bitsize */
2113 FALSE, /* pc_relative */
2114 0, /* bitpos */
2115 complain_overflow_dont,/* complain_on_overflow */
2116 nds32_elf_ignore_reloc,/* special_function */
2117 "R_NDS32_GOT_SUFF", /* name */
2118 FALSE, /* partial_inplace */
2119 0xffffffff, /* src_mask */
2120 0xffffffff, /* dst_mask */
2121 FALSE), /* pcrel_offset */
2122 HOWTO3 (R_NDS32_GOTOFF_SUFF, /* type */
2123 0, /* rightshift */
2124 2, /* size (0 = byte, 1 = short, 2 = long) */
2125 32, /* bitsize */
2126 FALSE, /* pc_relative */
2127 0, /* bitpos */
2128 complain_overflow_bitfield,/* complain_on_overflow */
2129 nds32_elf_ignore_reloc,/* special_function */
2130 "R_NDS32_GOTOFF_SUFF", /* name */
2131 FALSE, /* partial_inplace */
2132 0xffffffff, /* src_mask */
2133 0xffffffff, /* dst_mask */
2134 FALSE), /* pcrel_offset */
2135 HOWTO3 (R_NDS32_PLT_GOT_SUFF, /* type */
2136 0, /* rightshift */
2137 2, /* size (0 = byte, 1 = short, 2 = long) */
2138 32, /* bitsize */
2139 FALSE, /* pc_relative */
2140 0, /* bitpos */
2141 complain_overflow_dont,/* complain_on_overflow */
2142 nds32_elf_ignore_reloc,/* special_function */
2143 "R_NDS32_PLT_GOT_SUFF",/* name */
2144 FALSE, /* partial_inplace */
2145 0xffffffff, /* src_mask */
2146 0xffffffff, /* dst_mask */
2147 FALSE), /* pcrel_offset */
2148 HOWTO3 (R_NDS32_MULCALL_SUFF, /* type */
2149 0, /* rightshift */
2150 2, /* size (0 = byte, 1 = short, 2 = long) */
2151 32, /* bitsize */
2152 FALSE, /* pc_relative */
2153 0, /* bitpos */
2154 complain_overflow_dont,/* complain_on_overflow */
2155 nds32_elf_ignore_reloc,/* special_function */
2156 "R_NDS32_MULCALL_SUFF",/* name */
2157 FALSE, /* partial_inplace */
2158 0xffffffff, /* src_mask */
2159 0xffffffff, /* dst_mask */
2160 FALSE), /* pcrel_offset */
2161 HOWTO3 (R_NDS32_PTR, /* type */
2162 0, /* rightshift */
2163 2, /* size (0 = byte, 1 = short, 2 = long) */
2164 32, /* bitsize */
2165 FALSE, /* pc_relative */
2166 0, /* bitpos */
2167 complain_overflow_dont,/* complain_on_overflow */
2168 nds32_elf_ignore_reloc,/* special_function */
2169 "R_NDS32_PTR", /* name */
2170 FALSE, /* partial_inplace */
2171 0xffffffff, /* src_mask */
2172 0xffffffff, /* dst_mask */
2173 FALSE), /* pcrel_offset */
2174 HOWTO3 (R_NDS32_PTR_COUNT, /* type */
2175 0, /* rightshift */
2176 2, /* size (0 = byte, 1 = short, 2 = long) */
2177 32, /* bitsize */
2178 FALSE, /* pc_relative */
2179 0, /* bitpos */
2180 complain_overflow_dont,/* complain_on_overflow */
2181 nds32_elf_ignore_reloc,/* special_function */
2182 "R_NDS32_PTR_COUNT", /* name */
2183 FALSE, /* partial_inplace */
2184 0xffffffff, /* src_mask */
2185 0xffffffff, /* dst_mask */
2186 FALSE), /* pcrel_offset */
2187 HOWTO3 (R_NDS32_PTR_RESOLVED, /* type */
2188 0, /* rightshift */
2189 2, /* size (0 = byte, 1 = short, 2 = long) */
2190 32, /* bitsize */
2191 FALSE, /* pc_relative */
2192 0, /* bitpos */
2193 complain_overflow_dont,/* complain_on_overflow */
2194 nds32_elf_ignore_reloc,/* special_function */
2195 "R_NDS32_PTR_RESOLVED",/* name */
2196 FALSE, /* partial_inplace */
2197 0xffffffff, /* src_mask */
2198 0xffffffff, /* dst_mask */
2199 FALSE), /* pcrel_offset */
2200 HOWTO3 (R_NDS32_PLTBLOCK, /* type */
2201 0, /* rightshift */
2202 2, /* size (0 = byte, 1 = short, 2 = long) */
2203 32, /* bitsize */
2204 FALSE, /* pc_relative */
2205 0, /* bitpos */
2206 complain_overflow_dont,/* complain_on_overflow */
2207 nds32_elf_ignore_reloc,/* special_function */
2208 "R_NDS32_PLTBLOCK", /* name */
2209 FALSE, /* partial_inplace */
2210 0xffffffff, /* src_mask */
2211 0xffffffff, /* dst_mask */
2212 FALSE), /* pcrel_offset */
2213 HOWTO3 (R_NDS32_RELAX_REGION_BEGIN,/* type */
2214 0, /* rightshift */
2215 2, /* size (0 = byte, 1 = short, 2 = long) */
2216 32, /* bitsize */
2217 FALSE, /* pc_relative */
2218 0, /* bitpos */
2219 complain_overflow_dont,/* complain_on_overflow */
2220 nds32_elf_ignore_reloc,/* special_function */
2221 "R_NDS32_RELAX_REGION_BEGIN",/* name */
2222 FALSE, /* partial_inplace */
2223 0xffffffff, /* src_mask */
2224 0xffffffff, /* dst_mask */
2225 FALSE), /* pcrel_offset */
2226 HOWTO3 (R_NDS32_RELAX_REGION_END,/* type */
2227 0, /* rightshift */
2228 2, /* size (0 = byte, 1 = short, 2 = long) */
2229 32, /* bitsize */
2230 FALSE, /* pc_relative */
2231 0, /* bitpos */
2232 complain_overflow_dont,/* complain_on_overflow */
2233 nds32_elf_ignore_reloc,/* special_function */
2234 "R_NDS32_RELAX_REGION_END",/* name */
2235 FALSE, /* partial_inplace */
2236 0xffffffff, /* src_mask */
2237 0xffffffff, /* dst_mask */
2238 FALSE), /* pcrel_offset */
2239 HOWTO3 (R_NDS32_MINUEND, /* type */
2240 0, /* rightshift */
2241 2, /* size (0 = byte, 1 = short, 2 = long) */
2242 32, /* bitsize */
2243 FALSE, /* pc_relative */
2244 0, /* bitpos */
2245 complain_overflow_dont,/* complain_on_overflow */
2246 nds32_elf_ignore_reloc,/* special_function */
2247 "R_NDS32_MINUEND", /* name */
2248 FALSE, /* partial_inplace */
2249 0xffffffff, /* src_mask */
2250 0xffffffff, /* dst_mask */
2251 FALSE), /* pcrel_offset */
2252 HOWTO3 (R_NDS32_SUBTRAHEND, /* type */
2253 0, /* rightshift */
2254 2, /* size (0 = byte, 1 = short, 2 = long) */
2255 32, /* bitsize */
2256 FALSE, /* pc_relative */
2257 0, /* bitpos */
2258 complain_overflow_dont,/* complain_on_overflow */
2259 nds32_elf_ignore_reloc,/* special_function */
2260 "R_NDS32_SUBTRAHEND", /* name */
2261 FALSE, /* partial_inplace */
2262 0xffffffff, /* src_mask */
2263 0xffffffff, /* dst_mask */
2264 FALSE), /* pcrel_offset */
2265 HOWTO3 (R_NDS32_DIFF8, /* type */
2266 0, /* rightshift */
2267 0, /* size (0 = byte, 1 = short, 2 = long) */
2268 8, /* bitsize */
2269 FALSE, /* pc_relative */
2270 0, /* bitpos */
2271 complain_overflow_dont,/* complain_on_overflow */
2272 nds32_elf_ignore_reloc,/* special_function */
2273 "R_NDS32_DIFF8", /* name */
2274 FALSE, /* partial_inplace */
2275 0x000000ff, /* src_mask */
2276 0x000000ff, /* dst_mask */
2277 FALSE), /* pcrel_offset */
2278 HOWTO3 (R_NDS32_DIFF16, /* type */
2279 0, /* rightshift */
2280 1, /* size (0 = byte, 1 = short, 2 = long) */
2281 16, /* bitsize */
2282 FALSE, /* pc_relative */
2283 0, /* bitpos */
2284 complain_overflow_dont,/* complain_on_overflow */
2285 nds32_elf_ignore_reloc,/* special_function */
2286 "R_NDS32_DIFF16", /* name */
2287 FALSE, /* partial_inplace */
2288 0x0000ffff, /* src_mask */
2289 0x0000ffff, /* dst_mask */
2290 FALSE), /* pcrel_offset */
2291 HOWTO3 (R_NDS32_DIFF32, /* type */
2292 0, /* rightshift */
2293 2, /* size (0 = byte, 1 = short, 2 = long) */
2294 32, /* bitsize */
2295 FALSE, /* pc_relative */
2296 0, /* bitpos */
2297 complain_overflow_dont,/* complain_on_overflow */
2298 nds32_elf_ignore_reloc,/* special_function */
2299 "R_NDS32_DIFF32", /* name */
2300 FALSE, /* partial_inplace */
2301 0xffffffff, /* src_mask */
2302 0xffffffff, /* dst_mask */
2303 FALSE), /* pcrel_offset */
2304 HOWTO3 (R_NDS32_DIFF_ULEB128, /* type */
2305 0, /* rightshift */
2306 0, /* size (0 = byte, 1 = short, 2 = long) */
2307 0, /* bitsize */
2308 FALSE, /* pc_relative */
2309 0, /* bitpos */
2310 complain_overflow_dont,/* complain_on_overflow */
2311 nds32_elf_ignore_reloc,/* special_function */
2312 "R_NDS32_DIFF_ULEB128",/* name */
2313 FALSE, /* partial_inplace */
2314 0xffffffff, /* src_mask */
2315 0xffffffff, /* dst_mask */
2316 FALSE), /* pcrel_offset */
2317 HOWTO3 (R_NDS32_DATA, /* type */
2318 0, /* rightshift */
2319 2, /* size (0 = byte, 1 = short, 2 = long) */
2320 32, /* bitsize */
2321 FALSE, /* pc_relative */
2322 0, /* bitpos */
2323 complain_overflow_dont,/* complain_on_overflow */
2324 nds32_elf_ignore_reloc,/* special_function */
2325 "R_NDS32_DATA", /* name */
2326 FALSE, /* partial_inplace */
2327 0xffffffff, /* src_mask */
2328 0xffffffff, /* dst_mask */
2329 FALSE), /* pcrel_offset */
2330 HOWTO3 (R_NDS32_TRAN, /* type */
2331 0, /* rightshift */
2332 2, /* size (0 = byte, 1 = short, 2 = long) */
2333 32, /* bitsize */
2334 FALSE, /* pc_relative */
2335 0, /* bitpos */
2336 complain_overflow_dont,/* complain_on_overflow */
2337 nds32_elf_ignore_reloc,/* special_function */
2338 "R_NDS32_TRAN", /* name */
2339 FALSE, /* partial_inplace */
2340 0xffffffff, /* src_mask */
2341 0xffffffff, /* dst_mask */
2342 FALSE), /* pcrel_offset */
2343 HOWTO3 (R_NDS32_TLS_LE_ADD, /* type */
2344 0, /* rightshift */
2345 2, /* size (0 = byte, 1 = short, 2 = long) */
2346 32, /* bitsize */
2347 FALSE, /* pc_relative */
2348 0, /* bitpos */
2349 complain_overflow_dont,/* complain_on_overflow */
2350 nds32_elf_ignore_reloc,/* special_function */
2351 "R_NDS32_TLS_LE_ADD", /* name */
2352 FALSE, /* partial_inplace */
2353 0xffffffff, /* src_mask */
2354 0xffffffff, /* dst_mask */
2355 FALSE), /* pcrel_offset */
2356 HOWTO3 (R_NDS32_TLS_LE_LS, /* type */
2357 0, /* rightshift */
2358 2, /* size (0 = byte, 1 = short, 2 = long) */
2359 32, /* bitsize */
2360 FALSE, /* pc_relative */
2361 0, /* bitpos */
2362 complain_overflow_dont,/* complain_on_overflow */
2363 nds32_elf_ignore_reloc,/* special_function */
2364 "R_NDS32_TLS_LE_LS", /* name */
2365 FALSE, /* partial_inplace */
2366 0xffffffff, /* src_mask */
2367 0xffffffff, /* dst_mask */
2368 FALSE), /* pcrel_offset */
2369 HOWTO3 (R_NDS32_EMPTY, /* type */
2370 0, /* rightshift */
2371 2, /* size (0 = byte, 1 = short, 2 = long) */
2372 32, /* bitsize */
2373 FALSE, /* pc_relative */
2374 0, /* bitpos */
2375 complain_overflow_dont,/* complain_on_overflow */
2376 nds32_elf_ignore_reloc,/* special_function */
2377 "R_NDS32_EMPTY", /* name */
2378 FALSE, /* partial_inplace */
2379 0xffffffff, /* src_mask */
2380 0xffffffff, /* dst_mask */
2381 FALSE), /* pcrel_offset */
2382 /* TLS GD/LD description address base addition. */
2383 HOWTO3 (R_NDS32_TLS_DESC_ADD, /* type */
2384 0, /* rightshift */
2385 2, /* size (0 = byte, 1 = short, 2 = long) */
2386 32, /* bitsize */
2387 FALSE, /* pc_relative */
2388 0, /* bitpos */
2389 complain_overflow_dont,/* complain_on_overflow */
2390 nds32_elf_ignore_reloc,/* special_function */
2391 "R_NDS32_TLS_DESC_ADD",/* name */
2392 FALSE, /* partial_inplace */
2393 0xffffffff, /* src_mask */
2394 0xffffffff, /* dst_mask */
2395 FALSE), /* pcrel_offset */
2396 /* TLS GD/LD description function load. */
2397 HOWTO3 (R_NDS32_TLS_DESC_FUNC,/* type */
2398 0, /* rightshift */
2399 2, /* size (0 = byte, 1 = short, 2 = long) */
2400 32, /* bitsize */
2401 FALSE, /* pc_relative */
2402 0, /* bitpos */
2403 complain_overflow_dont,/* complain_on_overflow */
2404 nds32_elf_ignore_reloc,/* special_function */
2405 "R_NDS32_TLS_DESC_FUNC",/* name */
2406 FALSE, /* partial_inplace */
2407 0xffffffff, /* src_mask */
2408 0xffffffff, /* dst_mask */
2409 FALSE), /* pcrel_offset */
2410 /* TLS DESC resolve function call. */
2411 HOWTO3 (R_NDS32_TLS_DESC_CALL,/* type */
2412 0, /* rightshift */
2413 2, /* size (0 = byte, 1 = short, 2 = long) */
2414 32, /* bitsize */
2415 FALSE, /* pc_relative */
2416 0, /* bitpos */
2417 complain_overflow_dont,/* complain_on_overflow */
2418 nds32_elf_ignore_reloc,/* special_function */
2419 "R_NDS32_TLS_DESC_CALL",/* name */
2420 FALSE, /* partial_inplace */
2421 0xffffffff, /* src_mask */
2422 0xffffffff, /* dst_mask */
2423 FALSE), /* pcrel_offset */
2424 /* TLS DESC variable access. */
2425 HOWTO3 (R_NDS32_TLS_DESC_MEM, /* type */
2426 0, /* rightshift */
2427 2, /* size (0 = byte, 1 = short, 2 = long) */
2428 32, /* bitsize */
2429 FALSE, /* pc_relative */
2430 0, /* bitpos */
2431 complain_overflow_dont,/* complain_on_overflow */
2432 nds32_elf_ignore_reloc,/* special_function */
2433 "R_NDS32_TLS_DESC_MEM",/* name */
2434 FALSE, /* partial_inplace */
2435 0xffffffff, /* src_mask */
2436 0xffffffff, /* dst_mask */
2437 FALSE), /* pcrel_offset */
2438 /* TLS GD/LD description mark (@tlsdec). */
2439 HOWTO3 (R_NDS32_RELAX_REMOVE, /* type */
2440 0, /* rightshift */
2441 2, /* size (0 = byte, 1 = short, 2 = long) */
2442 32, /* bitsize */
2443 FALSE, /* pc_relative */
2444 0, /* bitpos */
2445 complain_overflow_dont,/* complain_on_overflow */
2446 nds32_elf_ignore_reloc,/* special_function */
2447 "R_NDS32_REMOVE", /* name */
2448 FALSE, /* partial_inplace */
2449 0xffffffff, /* src_mask */
2450 0xffffffff, /* dst_mask */
2451 FALSE), /* pcrel_offset */
2452 /* TLS GD/LD description mark (@tlsdec). */
2453 HOWTO3 (R_NDS32_RELAX_GROUP, /* type */
2454 0, /* rightshift */
2455 2, /* size (0 = byte, 1 = short, 2 = long) */
2456 32, /* bitsize */
2457 FALSE, /* pc_relative */
2458 0, /* bitpos */
2459 complain_overflow_dont,/* complain_on_overflow */
2460 nds32_elf_ignore_reloc,/* special_function */
2461 "R_NDS32_GROUP", /* name */
2462 FALSE, /* partial_inplace */
2463 0xffffffff, /* src_mask */
2464 0xffffffff, /* dst_mask */
2465 FALSE), /* pcrel_offset */
2466 HOWTO3 (R_NDS32_TLS_IEGP_LW, /* type */
2467 0, /* rightshift */
2468 2, /* size (0 = byte, 1 = short, 2 = long) */
2469 32, /* bitsize */
2470 FALSE, /* pc_relative */
2471 0, /* bitpos */
2472 complain_overflow_dont,/* complain_on_overflow */
2473 nds32_elf_ignore_reloc,/* special_function */
2474 "R_NDS32_TLS_IEGP_LW", /* name */
2475 FALSE, /* partial_inplace */
2476 0xffffffff, /* src_mask */
2477 0xffffffff, /* dst_mask */
2478 FALSE), /* pcrel_offset */
2479 /* LA and FLSI relaxation. */
2480 HOWTO3 (R_NDS32_LSI, /* type */
2481 0, /* rightshift */
2482 2, /* size (0 = byte, 1 = short, 2 = long) */
2483 32, /* bitsize */
2484 FALSE, /* pc_relative */
2485 0, /* bitpos */
2486 complain_overflow_dont,/* complain_on_overflow */
2487 nds32_elf_ignore_reloc,/* special_function */
2488 "R_NDS32_LSI", /* name */
2489 FALSE, /* partial_inplace */
2490 0xffffffff, /* src_mask */
2491 0xffffffff, /* dst_mask */
2492 FALSE),
2493 };
2494
2495 static unsigned long dl_tlsdesc_lazy_trampoline[] =
2496 {
2497 0x46200000, /* sethi $r2,#0x0 */
2498 0x58210000, /* ori $r2,$r2,#0x0 */
2499 0x40217400, /* add $r2,$r2,$gp */
2500 0x04210000, /* lwi $r2,[$r2+#0x0] */
2501 0x46300000, /* sethi $r3,#0x0 */
2502 0x58318000, /* ori $r3,$r3,#0x0 */
2503 0x4031f400, /* add $r3,$r3,$gp */
2504 0x4a000800, /* jr $r2 */
2505 };
2506
2507 static void
2508 nds32_put_trampoline (void *contents, const unsigned long *template,
2509 unsigned count)
2510 {
2511 unsigned ix;
2512
2513 for (ix = 0; ix != count; ix++)
2514 {
2515 unsigned long insn = template[ix];
2516 bfd_putb32 (insn, (char *) contents + ix * 4);
2517 }
2518 }
2519
2520 /* nds32_insertion_sort sorts an array with nmemb elements of size size.
2521 This prototype is the same as qsort (). */
2522
2523 void
2524 nds32_insertion_sort (void *base, size_t nmemb, size_t size,
2525 int (*compar) (const void *lhs, const void *rhs))
2526 {
2527 char *ptr = (char *) base;
2528 int i, j;
2529 char *tmp = xmalloc (size);
2530
2531 /* If i is less than j, i is inserted before j.
2532
2533 |---- j ----- i --------------|
2534 \ / \ /
2535 sorted unsorted
2536 */
2537
2538 for (i = 1; i < (int) nmemb; i++)
2539 {
2540 for (j = (i - 1); j >= 0; j--)
2541 if (compar (ptr + i * size, ptr + j * size) >= 0)
2542 break;
2543
2544 j++;
2545
2546 if (i == j)
2547 continue; /* i is in order. */
2548
2549 memcpy (tmp, ptr + i * size, size);
2550 memmove (ptr + (j + 1) * size, ptr + j * size, (i - j) * size);
2551 memcpy (ptr + j * size, tmp, size);
2552 }
2553 free (tmp);
2554 }
2555
2556 /* Sort relocation by r_offset.
2557
2558 We didn't use qsort () in stdlib, because quick-sort is not a stable sorting
2559 algorithm. Relocations at the same r_offset must keep their order.
2560 For example, RELAX_ENTRY must be the very first relocation entry.
2561
2562 Currently, this function implements insertion-sort.
2563
2564 FIXME: If we already sort them in assembler, why bother sort them
2565 here again? */
2566
2567 static int
2568 compar_reloc (const void *lhs, const void *rhs)
2569 {
2570 const Elf_Internal_Rela *l = (const Elf_Internal_Rela *) lhs;
2571 const Elf_Internal_Rela *r = (const Elf_Internal_Rela *) rhs;
2572
2573 if (l->r_offset > r->r_offset)
2574 return 1;
2575 else if (l->r_offset == r->r_offset)
2576 return 0;
2577 else
2578 return -1;
2579 }
2580
2581 /* Functions listed below are only used for old relocs.
2582 nds32_elf_9_pcrel_reloc
2583 nds32_elf_do_9_pcrel_reloc
2584 nds32_elf_hi20_reloc
2585 nds32_elf_relocate_hi20
2586 nds32_elf_lo12_reloc
2587 nds32_elf_sda15_reloc
2588 nds32_elf_generic_reloc. */
2589
2590 /* Handle the R_NDS32_9_PCREL & R_NDS32_9_PCREL_RELA reloc. */
2591
2592 static bfd_reloc_status_type
2593 nds32_elf_9_pcrel_reloc (bfd * abfd,
2594 arelent * reloc_entry,
2595 asymbol * symbol,
2596 void * data,
2597 asection * input_section,
2598 bfd * output_bfd,
2599 char ** error_message ATTRIBUTE_UNUSED)
2600 {
2601 /* This part is from bfd_elf_generic_reloc. */
2602 if (output_bfd != (bfd *) NULL
2603 && (symbol->flags & BSF_SECTION_SYM) == 0
2604 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2605 {
2606 reloc_entry->address += input_section->output_offset;
2607 return bfd_reloc_ok;
2608 }
2609
2610 if (output_bfd != NULL)
2611 {
2612 /* FIXME: See bfd_perform_relocation. Is this right? */
2613 return bfd_reloc_continue;
2614 }
2615
2616 return nds32_elf_do_9_pcrel_reloc (abfd, reloc_entry->howto,
2617 input_section,
2618 data, reloc_entry->address,
2619 symbol->section,
2620 (symbol->value
2621 + symbol->section->output_section->vma
2622 + symbol->section->output_offset),
2623 reloc_entry->addend);
2624 }
2625
2626 /* Utility to actually perform an R_NDS32_9_PCREL reloc. */
2627 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
2628
2629 static bfd_reloc_status_type
2630 nds32_elf_do_9_pcrel_reloc (bfd * abfd,
2631 reloc_howto_type * howto,
2632 asection * input_section,
2633 bfd_byte * data,
2634 bfd_vma offset,
2635 asection * symbol_section ATTRIBUTE_UNUSED,
2636 bfd_vma symbol_value,
2637 bfd_vma addend)
2638 {
2639 bfd_signed_vma relocation;
2640 unsigned short x;
2641 bfd_reloc_status_type status;
2642
2643 /* Sanity check the address (offset in section). */
2644 if (offset > bfd_get_section_limit (abfd, input_section))
2645 return bfd_reloc_outofrange;
2646
2647 relocation = symbol_value + addend;
2648 /* Make it pc relative. */
2649 relocation -= (input_section->output_section->vma
2650 + input_section->output_offset);
2651 /* These jumps mask off the lower two bits of the current address
2652 before doing pcrel calculations. */
2653 relocation -= (offset & -(bfd_vma) 2);
2654
2655 if (relocation < -ACCURATE_8BIT_S1 || relocation >= ACCURATE_8BIT_S1)
2656 status = bfd_reloc_overflow;
2657 else
2658 status = bfd_reloc_ok;
2659
2660 x = bfd_getb16 (data + offset);
2661
2662 relocation >>= howto->rightshift;
2663 relocation <<= howto->bitpos;
2664 x = (x & ~howto->dst_mask)
2665 | (((x & howto->src_mask) + relocation) & howto->dst_mask);
2666
2667 bfd_putb16 ((bfd_vma) x, data + offset);
2668
2669 return status;
2670 }
2671
2672 /* Handle the R_NDS32_HI20_[SU]LO relocs.
2673 HI20_SLO is for the add3 and load/store with displacement instructions.
2674 HI20 is for the or3 instruction.
2675 For R_NDS32_HI20_SLO, the lower 16 bits are sign extended when added to
2676 the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
2677 we must add one to the high 16 bytes (which will get subtracted off when
2678 the low 16 bits are added).
2679 These relocs have to be done in combination with an R_NDS32_LO12 reloc
2680 because there is a carry from the LO12 to the HI20. Here we just save
2681 the information we need; we do the actual relocation when we see the LO12.
2682 This code is copied from the elf32-mips.c. We also support an arbitrary
2683 number of HI20 relocs to be associated with a single LO12 reloc. The
2684 assembler sorts the relocs to ensure each HI20 immediately precedes its
2685 LO12. However if there are multiple copies, the assembler may not find
2686 the real LO12 so it picks the first one it finds. */
2687
2688 struct nds32_hi20
2689 {
2690 struct nds32_hi20 *next;
2691 bfd_byte *addr;
2692 bfd_vma addend;
2693 };
2694
2695 static struct nds32_hi20 *nds32_hi20_list;
2696
2697 static bfd_reloc_status_type
2698 nds32_elf_hi20_reloc (bfd *abfd ATTRIBUTE_UNUSED,
2699 arelent *reloc_entry,
2700 asymbol *symbol,
2701 void *data,
2702 asection *input_section,
2703 bfd *output_bfd,
2704 char **error_message ATTRIBUTE_UNUSED)
2705 {
2706 bfd_reloc_status_type ret;
2707 bfd_vma relocation;
2708 struct nds32_hi20 *n;
2709
2710 /* This part is from bfd_elf_generic_reloc.
2711 If we're relocating, and this an external symbol, we don't want
2712 to change anything. */
2713 if (output_bfd != (bfd *) NULL
2714 && (symbol->flags & BSF_SECTION_SYM) == 0 && reloc_entry->addend == 0)
2715 {
2716 reloc_entry->address += input_section->output_offset;
2717 return bfd_reloc_ok;
2718 }
2719
2720 /* Sanity check the address (offset in section). */
2721 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2722 return bfd_reloc_outofrange;
2723
2724 ret = bfd_reloc_ok;
2725 if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2726 ret = bfd_reloc_undefined;
2727
2728 if (bfd_is_com_section (symbol->section))
2729 relocation = 0;
2730 else
2731 relocation = symbol->value;
2732
2733 relocation += symbol->section->output_section->vma;
2734 relocation += symbol->section->output_offset;
2735 relocation += reloc_entry->addend;
2736
2737 /* Save the information, and let LO12 do the actual relocation. */
2738 n = (struct nds32_hi20 *) bfd_malloc ((bfd_size_type) sizeof *n);
2739 if (n == NULL)
2740 return bfd_reloc_outofrange;
2741
2742 n->addr = (bfd_byte *) data + reloc_entry->address;
2743 n->addend = relocation;
2744 n->next = nds32_hi20_list;
2745 nds32_hi20_list = n;
2746
2747 if (output_bfd != (bfd *) NULL)
2748 reloc_entry->address += input_section->output_offset;
2749
2750 return ret;
2751 }
2752
2753 /* Handle an NDS32 ELF HI20 reloc. */
2754
2755 static void
2756 nds32_elf_relocate_hi20 (bfd *input_bfd ATTRIBUTE_UNUSED,
2757 int type ATTRIBUTE_UNUSED,
2758 Elf_Internal_Rela *relhi,
2759 Elf_Internal_Rela *rello,
2760 bfd_byte *contents,
2761 bfd_vma addend)
2762 {
2763 unsigned long insn;
2764 bfd_vma addlo;
2765
2766 insn = bfd_getb32 (contents + relhi->r_offset);
2767
2768 addlo = bfd_getb32 (contents + rello->r_offset);
2769 addlo &= 0xfff;
2770
2771 addend += ((insn & 0xfffff) << 20) + addlo;
2772
2773 insn = (insn & 0xfff00000) | ((addend >> 12) & 0xfffff);
2774 bfd_putb32 (insn, contents + relhi->r_offset);
2775 }
2776
2777 /* Do an R_NDS32_LO12 relocation. This is a straightforward 12 bit
2778 inplace relocation; this function exists in order to do the
2779 R_NDS32_HI20_[SU]LO relocation described above. */
2780
2781 static bfd_reloc_status_type
2782 nds32_elf_lo12_reloc (bfd *input_bfd, arelent *reloc_entry, asymbol *symbol,
2783 void *data, asection *input_section, bfd *output_bfd,
2784 char **error_message)
2785 {
2786 /* This part is from bfd_elf_generic_reloc.
2787 If we're relocating, and this an external symbol, we don't want
2788 to change anything. */
2789 if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2790 && reloc_entry->addend == 0)
2791 {
2792 reloc_entry->address += input_section->output_offset;
2793 return bfd_reloc_ok;
2794 }
2795
2796 if (nds32_hi20_list != NULL)
2797 {
2798 struct nds32_hi20 *l;
2799
2800 l = nds32_hi20_list;
2801 while (l != NULL)
2802 {
2803 unsigned long insn;
2804 unsigned long val;
2805 unsigned long vallo;
2806 struct nds32_hi20 *next;
2807
2808 /* Do the HI20 relocation. Note that we actually don't need
2809 to know anything about the LO12 itself, except where to
2810 find the low 12 bits of the addend needed by the LO12. */
2811 insn = bfd_getb32 (l->addr);
2812 vallo = bfd_getb32 ((bfd_byte *) data + reloc_entry->address);
2813 vallo &= 0xfff;
2814 switch (reloc_entry->howto->type)
2815 {
2816 case R_NDS32_LO12S3:
2817 vallo <<= 3;
2818 break;
2819
2820 case R_NDS32_LO12S2:
2821 vallo <<= 2;
2822 break;
2823
2824 case R_NDS32_LO12S1:
2825 vallo <<= 1;
2826 break;
2827
2828 case R_NDS32_LO12S0:
2829 vallo <<= 0;
2830 break;
2831 }
2832
2833 val = ((insn & 0xfffff) << 12) + vallo;
2834 val += l->addend;
2835
2836 insn = (insn & ~(bfd_vma) 0xfffff) | ((val >> 12) & 0xfffff);
2837 bfd_putb32 ((bfd_vma) insn, l->addr);
2838
2839 next = l->next;
2840 free (l);
2841 l = next;
2842 }
2843
2844 nds32_hi20_list = NULL;
2845 }
2846
2847 /* Now do the LO12 reloc in the usual way.
2848 ??? It would be nice to call bfd_elf_generic_reloc here,
2849 but we have partial_inplace set. bfd_elf_generic_reloc will
2850 pass the handling back to bfd_install_relocation which will install
2851 a section relative addend which is wrong. */
2852 return nds32_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
2853 input_section, output_bfd, error_message);
2854 }
2855
2856 /* Do generic partial_inplace relocation.
2857 This is a local replacement for bfd_elf_generic_reloc. */
2858
2859 static bfd_reloc_status_type
2860 nds32_elf_generic_reloc (bfd *input_bfd, arelent *reloc_entry,
2861 asymbol *symbol, void *data, asection *input_section,
2862 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2863 {
2864 bfd_reloc_status_type ret;
2865 bfd_vma relocation;
2866 bfd_byte *inplace_address;
2867
2868 /* This part is from bfd_elf_generic_reloc.
2869 If we're relocating, and this an external symbol, we don't want
2870 to change anything. */
2871 if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2872 && reloc_entry->addend == 0)
2873 {
2874 reloc_entry->address += input_section->output_offset;
2875 return bfd_reloc_ok;
2876 }
2877
2878 /* Now do the reloc in the usual way.
2879 ??? It would be nice to call bfd_elf_generic_reloc here,
2880 but we have partial_inplace set. bfd_elf_generic_reloc will
2881 pass the handling back to bfd_install_relocation which will install
2882 a section relative addend which is wrong. */
2883
2884 /* Sanity check the address (offset in section). */
2885 if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section))
2886 return bfd_reloc_outofrange;
2887
2888 ret = bfd_reloc_ok;
2889 if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2890 ret = bfd_reloc_undefined;
2891
2892 if (bfd_is_com_section (symbol->section) || output_bfd != (bfd *) NULL)
2893 relocation = 0;
2894 else
2895 relocation = symbol->value;
2896
2897 /* Only do this for a final link. */
2898 if (output_bfd == (bfd *) NULL)
2899 {
2900 relocation += symbol->section->output_section->vma;
2901 relocation += symbol->section->output_offset;
2902 }
2903
2904 relocation += reloc_entry->addend;
2905 switch (reloc_entry->howto->type)
2906 {
2907 case R_NDS32_LO12S3:
2908 relocation >>= 3;
2909 break;
2910
2911 case R_NDS32_LO12S2:
2912 relocation >>= 2;
2913 break;
2914
2915 case R_NDS32_LO12S1:
2916 relocation >>= 1;
2917 break;
2918
2919 case R_NDS32_LO12S0:
2920 default:
2921 relocation >>= 0;
2922 break;
2923 }
2924
2925 inplace_address = (bfd_byte *) data + reloc_entry->address;
2926
2927 #define DOIT(x) \
2928 x = ((x & ~reloc_entry->howto->dst_mask) | \
2929 (((x & reloc_entry->howto->src_mask) + relocation) & \
2930 reloc_entry->howto->dst_mask))
2931
2932 switch (reloc_entry->howto->size)
2933 {
2934 case 1:
2935 {
2936 short x = bfd_getb16 (inplace_address);
2937
2938 DOIT (x);
2939 bfd_putb16 ((bfd_vma) x, inplace_address);
2940 }
2941 break;
2942 case 2:
2943 {
2944 unsigned long x = bfd_getb32 (inplace_address);
2945
2946 DOIT (x);
2947 bfd_putb32 ((bfd_vma) x, inplace_address);
2948 }
2949 break;
2950 default:
2951 BFD_ASSERT (0);
2952 }
2953
2954 if (output_bfd != (bfd *) NULL)
2955 reloc_entry->address += input_section->output_offset;
2956
2957 return ret;
2958 }
2959
2960 /* Handle the R_NDS32_SDA15 reloc.
2961 This reloc is used to compute the address of objects in the small data area
2962 and to perform loads and stores from that area.
2963 The lower 15 bits are sign extended and added to the register specified
2964 in the instruction, which is assumed to point to _SDA_BASE_.
2965
2966 Since the lower 15 bits offset is left-shifted 0, 1 or 2 bits depending on
2967 the access size, this must be taken care of. */
2968
2969 static bfd_reloc_status_type
2970 nds32_elf_sda15_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2971 asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2972 asection *input_section, bfd *output_bfd,
2973 char **error_message ATTRIBUTE_UNUSED)
2974 {
2975 /* This part is from bfd_elf_generic_reloc. */
2976 if (output_bfd != (bfd *) NULL
2977 && (symbol->flags & BSF_SECTION_SYM) == 0
2978 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2979 {
2980 reloc_entry->address += input_section->output_offset;
2981 return bfd_reloc_ok;
2982 }
2983
2984 if (output_bfd != NULL)
2985 {
2986 /* FIXME: See bfd_perform_relocation. Is this right? */
2987 return bfd_reloc_continue;
2988 }
2989
2990 /* FIXME: not sure what to do here yet. But then again, the linker
2991 may never call us. */
2992 abort ();
2993 }
2994
2995 /* nds32_elf_ignore_reloc is the special function for
2996 relocation types which don't need to be relocated
2997 like relaxation relocation types.
2998 This function simply return bfd_reloc_ok when it is
2999 invoked. */
3000
3001 static bfd_reloc_status_type
3002 nds32_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
3003 asymbol *symbol ATTRIBUTE_UNUSED,
3004 void *data ATTRIBUTE_UNUSED, asection *input_section,
3005 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
3006 {
3007 if (output_bfd != NULL)
3008 reloc_entry->address += input_section->output_offset;
3009
3010 return bfd_reloc_ok;
3011 }
3012 \f
3013
3014 /* Map BFD reloc types to NDS32 ELF reloc types. */
3015
3016 struct nds32_reloc_map_entry
3017 {
3018 bfd_reloc_code_real_type bfd_reloc_val;
3019 unsigned char elf_reloc_val;
3020 };
3021
3022 static const struct nds32_reloc_map_entry nds32_reloc_map[] =
3023 {
3024 {BFD_RELOC_NONE, R_NDS32_NONE},
3025 {BFD_RELOC_16, R_NDS32_16_RELA},
3026 {BFD_RELOC_32, R_NDS32_32_RELA},
3027 {BFD_RELOC_VTABLE_INHERIT, R_NDS32_RELA_GNU_VTINHERIT},
3028 {BFD_RELOC_VTABLE_ENTRY, R_NDS32_RELA_GNU_VTENTRY},
3029
3030 {BFD_RELOC_NDS32_20, R_NDS32_20_RELA},
3031 {BFD_RELOC_NDS32_9_PCREL, R_NDS32_9_PCREL_RELA},
3032 {BFD_RELOC_NDS32_WORD_9_PCREL, R_NDS32_WORD_9_PCREL_RELA},
3033 {BFD_RELOC_NDS32_15_PCREL, R_NDS32_15_PCREL_RELA},
3034 {BFD_RELOC_NDS32_17_PCREL, R_NDS32_17_PCREL_RELA},
3035 {BFD_RELOC_NDS32_25_PCREL, R_NDS32_25_PCREL_RELA},
3036 {BFD_RELOC_NDS32_HI20, R_NDS32_HI20_RELA},
3037 {BFD_RELOC_NDS32_LO12S3, R_NDS32_LO12S3_RELA},
3038 {BFD_RELOC_NDS32_LO12S2, R_NDS32_LO12S2_RELA},
3039 {BFD_RELOC_NDS32_LO12S1, R_NDS32_LO12S1_RELA},
3040 {BFD_RELOC_NDS32_LO12S0, R_NDS32_LO12S0_RELA},
3041 {BFD_RELOC_NDS32_LO12S0_ORI, R_NDS32_LO12S0_ORI_RELA},
3042 {BFD_RELOC_NDS32_SDA15S3, R_NDS32_SDA15S3_RELA},
3043 {BFD_RELOC_NDS32_SDA15S2, R_NDS32_SDA15S2_RELA},
3044 {BFD_RELOC_NDS32_SDA15S1, R_NDS32_SDA15S1_RELA},
3045 {BFD_RELOC_NDS32_SDA15S0, R_NDS32_SDA15S0_RELA},
3046 {BFD_RELOC_NDS32_SDA16S3, R_NDS32_SDA16S3_RELA},
3047 {BFD_RELOC_NDS32_SDA17S2, R_NDS32_SDA17S2_RELA},
3048 {BFD_RELOC_NDS32_SDA18S1, R_NDS32_SDA18S1_RELA},
3049 {BFD_RELOC_NDS32_SDA19S0, R_NDS32_SDA19S0_RELA},
3050 {BFD_RELOC_NDS32_GOT20, R_NDS32_GOT20},
3051 {BFD_RELOC_NDS32_9_PLTREL, R_NDS32_9_PLTREL},
3052 {BFD_RELOC_NDS32_25_PLTREL, R_NDS32_25_PLTREL},
3053 {BFD_RELOC_NDS32_COPY, R_NDS32_COPY},
3054 {BFD_RELOC_NDS32_GLOB_DAT, R_NDS32_GLOB_DAT},
3055 {BFD_RELOC_NDS32_JMP_SLOT, R_NDS32_JMP_SLOT},
3056 {BFD_RELOC_NDS32_RELATIVE, R_NDS32_RELATIVE},
3057 {BFD_RELOC_NDS32_GOTOFF, R_NDS32_GOTOFF},
3058 {BFD_RELOC_NDS32_GOTOFF_HI20, R_NDS32_GOTOFF_HI20},
3059 {BFD_RELOC_NDS32_GOTOFF_LO12, R_NDS32_GOTOFF_LO12},
3060 {BFD_RELOC_NDS32_GOTPC20, R_NDS32_GOTPC20},
3061 {BFD_RELOC_NDS32_GOT_HI20, R_NDS32_GOT_HI20},
3062 {BFD_RELOC_NDS32_GOT_LO12, R_NDS32_GOT_LO12},
3063 {BFD_RELOC_NDS32_GOTPC_HI20, R_NDS32_GOTPC_HI20},
3064 {BFD_RELOC_NDS32_GOTPC_LO12, R_NDS32_GOTPC_LO12},
3065 {BFD_RELOC_NDS32_INSN16, R_NDS32_INSN16},
3066 {BFD_RELOC_NDS32_LABEL, R_NDS32_LABEL},
3067 {BFD_RELOC_NDS32_LONGCALL1, R_NDS32_LONGCALL1},
3068 {BFD_RELOC_NDS32_LONGCALL2, R_NDS32_LONGCALL2},
3069 {BFD_RELOC_NDS32_LONGCALL3, R_NDS32_LONGCALL3},
3070 {BFD_RELOC_NDS32_LONGJUMP1, R_NDS32_LONGJUMP1},
3071 {BFD_RELOC_NDS32_LONGJUMP2, R_NDS32_LONGJUMP2},
3072 {BFD_RELOC_NDS32_LONGJUMP3, R_NDS32_LONGJUMP3},
3073 {BFD_RELOC_NDS32_LOADSTORE, R_NDS32_LOADSTORE},
3074 {BFD_RELOC_NDS32_9_FIXED, R_NDS32_9_FIXED_RELA},
3075 {BFD_RELOC_NDS32_15_FIXED, R_NDS32_15_FIXED_RELA},
3076 {BFD_RELOC_NDS32_17_FIXED, R_NDS32_17_FIXED_RELA},
3077 {BFD_RELOC_NDS32_25_FIXED, R_NDS32_25_FIXED_RELA},
3078 {BFD_RELOC_NDS32_LONGCALL4, R_NDS32_LONGCALL4},
3079 {BFD_RELOC_NDS32_LONGCALL5, R_NDS32_LONGCALL5},
3080 {BFD_RELOC_NDS32_LONGCALL6, R_NDS32_LONGCALL6},
3081 {BFD_RELOC_NDS32_LONGJUMP4, R_NDS32_LONGJUMP4},
3082 {BFD_RELOC_NDS32_LONGJUMP5, R_NDS32_LONGJUMP5},
3083 {BFD_RELOC_NDS32_LONGJUMP6, R_NDS32_LONGJUMP6},
3084 {BFD_RELOC_NDS32_LONGJUMP7, R_NDS32_LONGJUMP7},
3085 {BFD_RELOC_NDS32_PLTREL_HI20, R_NDS32_PLTREL_HI20},
3086 {BFD_RELOC_NDS32_PLTREL_LO12, R_NDS32_PLTREL_LO12},
3087 {BFD_RELOC_NDS32_PLT_GOTREL_HI20, R_NDS32_PLT_GOTREL_HI20},
3088 {BFD_RELOC_NDS32_PLT_GOTREL_LO12, R_NDS32_PLT_GOTREL_LO12},
3089 {BFD_RELOC_NDS32_SDA12S2_DP, R_NDS32_SDA12S2_DP_RELA},
3090 {BFD_RELOC_NDS32_SDA12S2_SP, R_NDS32_SDA12S2_SP_RELA},
3091 {BFD_RELOC_NDS32_LO12S2_DP, R_NDS32_LO12S2_DP_RELA},
3092 {BFD_RELOC_NDS32_LO12S2_SP, R_NDS32_LO12S2_SP_RELA},
3093 {BFD_RELOC_NDS32_DWARF2_OP1, R_NDS32_DWARF2_OP1_RELA},
3094 {BFD_RELOC_NDS32_DWARF2_OP2, R_NDS32_DWARF2_OP2_RELA},
3095 {BFD_RELOC_NDS32_DWARF2_LEB, R_NDS32_DWARF2_LEB_RELA},
3096 {BFD_RELOC_NDS32_UPDATE_TA, R_NDS32_UPDATE_TA_RELA},
3097 {BFD_RELOC_NDS32_PLT_GOTREL_LO20, R_NDS32_PLT_GOTREL_LO20},
3098 {BFD_RELOC_NDS32_PLT_GOTREL_LO15, R_NDS32_PLT_GOTREL_LO15},
3099 {BFD_RELOC_NDS32_PLT_GOTREL_LO19, R_NDS32_PLT_GOTREL_LO19},
3100 {BFD_RELOC_NDS32_GOT_LO15, R_NDS32_GOT_LO15},
3101 {BFD_RELOC_NDS32_GOT_LO19, R_NDS32_GOT_LO19},
3102 {BFD_RELOC_NDS32_GOTOFF_LO15, R_NDS32_GOTOFF_LO15},
3103 {BFD_RELOC_NDS32_GOTOFF_LO19, R_NDS32_GOTOFF_LO19},
3104 {BFD_RELOC_NDS32_GOT15S2, R_NDS32_GOT15S2_RELA},
3105 {BFD_RELOC_NDS32_GOT17S2, R_NDS32_GOT17S2_RELA},
3106 {BFD_RELOC_NDS32_5, R_NDS32_5_RELA},
3107 {BFD_RELOC_NDS32_10_UPCREL, R_NDS32_10_UPCREL_RELA},
3108 {BFD_RELOC_NDS32_SDA_FP7U2_RELA, R_NDS32_SDA_FP7U2_RELA},
3109 {BFD_RELOC_NDS32_RELAX_ENTRY, R_NDS32_RELAX_ENTRY},
3110 {BFD_RELOC_NDS32_GOT_SUFF, R_NDS32_GOT_SUFF},
3111 {BFD_RELOC_NDS32_GOTOFF_SUFF, R_NDS32_GOTOFF_SUFF},
3112 {BFD_RELOC_NDS32_PLT_GOT_SUFF, R_NDS32_PLT_GOT_SUFF},
3113 {BFD_RELOC_NDS32_MULCALL_SUFF, R_NDS32_MULCALL_SUFF},
3114 {BFD_RELOC_NDS32_PTR, R_NDS32_PTR},
3115 {BFD_RELOC_NDS32_PTR_COUNT, R_NDS32_PTR_COUNT},
3116 {BFD_RELOC_NDS32_PTR_RESOLVED, R_NDS32_PTR_RESOLVED},
3117 {BFD_RELOC_NDS32_PLTBLOCK, R_NDS32_PLTBLOCK},
3118 {BFD_RELOC_NDS32_RELAX_REGION_BEGIN, R_NDS32_RELAX_REGION_BEGIN},
3119 {BFD_RELOC_NDS32_RELAX_REGION_END, R_NDS32_RELAX_REGION_END},
3120 {BFD_RELOC_NDS32_MINUEND, R_NDS32_MINUEND},
3121 {BFD_RELOC_NDS32_SUBTRAHEND, R_NDS32_SUBTRAHEND},
3122 {BFD_RELOC_NDS32_DIFF8, R_NDS32_DIFF8},
3123 {BFD_RELOC_NDS32_DIFF16, R_NDS32_DIFF16},
3124 {BFD_RELOC_NDS32_DIFF32, R_NDS32_DIFF32},
3125 {BFD_RELOC_NDS32_DIFF_ULEB128, R_NDS32_DIFF_ULEB128},
3126 {BFD_RELOC_NDS32_EMPTY, R_NDS32_EMPTY},
3127 {BFD_RELOC_NDS32_25_ABS, R_NDS32_25_ABS_RELA},
3128 {BFD_RELOC_NDS32_DATA, R_NDS32_DATA},
3129 {BFD_RELOC_NDS32_TRAN, R_NDS32_TRAN},
3130 {BFD_RELOC_NDS32_17IFC_PCREL, R_NDS32_17IFC_PCREL_RELA},
3131 {BFD_RELOC_NDS32_10IFCU_PCREL, R_NDS32_10IFCU_PCREL_RELA},
3132 /* Not sure. */
3133 {BFD_RELOC_NDS32_TPOFF, R_NDS32_TLS_TPOFF},
3134 /* Missing: BFD_RELOC_NDS32_GOTTPOFF. */
3135 {BFD_RELOC_NDS32_TLS_LE_HI20, R_NDS32_TLS_LE_HI20},
3136 {BFD_RELOC_NDS32_TLS_LE_LO12, R_NDS32_TLS_LE_LO12},
3137 {BFD_RELOC_NDS32_TLS_LE_20, R_NDS32_TLS_LE_20},
3138 {BFD_RELOC_NDS32_TLS_LE_15S0, R_NDS32_TLS_LE_15S0},
3139 {BFD_RELOC_NDS32_TLS_LE_15S1, R_NDS32_TLS_LE_15S1},
3140 {BFD_RELOC_NDS32_TLS_LE_15S2, R_NDS32_TLS_LE_15S2},
3141 {BFD_RELOC_NDS32_TLS_LE_ADD, R_NDS32_TLS_LE_ADD},
3142 {BFD_RELOC_NDS32_TLS_LE_LS, R_NDS32_TLS_LE_LS},
3143 {BFD_RELOC_NDS32_TLS_IE_HI20, R_NDS32_TLS_IE_HI20},
3144 {BFD_RELOC_NDS32_TLS_IE_LO12, R_NDS32_TLS_IE_LO12},
3145 {BFD_RELOC_NDS32_TLS_IE_LO12S2, R_NDS32_TLS_IE_LO12S2},
3146 {BFD_RELOC_NDS32_TLS_IEGP_HI20, R_NDS32_TLS_IEGP_HI20},
3147 {BFD_RELOC_NDS32_TLS_IEGP_LO12, R_NDS32_TLS_IEGP_LO12},
3148 {BFD_RELOC_NDS32_TLS_IEGP_LO12S2, R_NDS32_TLS_IEGP_LO12S2},
3149 {BFD_RELOC_NDS32_TLS_IEGP_LW, R_NDS32_TLS_IEGP_LW},
3150 {BFD_RELOC_NDS32_TLS_DESC, R_NDS32_TLS_DESC},
3151 {BFD_RELOC_NDS32_TLS_DESC_HI20, R_NDS32_TLS_DESC_HI20},
3152 {BFD_RELOC_NDS32_TLS_DESC_LO12, R_NDS32_TLS_DESC_LO12},
3153 {BFD_RELOC_NDS32_TLS_DESC_20, R_NDS32_TLS_DESC_20},
3154 {BFD_RELOC_NDS32_TLS_DESC_SDA17S2, R_NDS32_TLS_DESC_SDA17S2},
3155 {BFD_RELOC_NDS32_TLS_DESC_ADD, R_NDS32_TLS_DESC_ADD},
3156 {BFD_RELOC_NDS32_TLS_DESC_FUNC, R_NDS32_TLS_DESC_FUNC},
3157 {BFD_RELOC_NDS32_TLS_DESC_CALL, R_NDS32_TLS_DESC_CALL},
3158 {BFD_RELOC_NDS32_TLS_DESC_MEM, R_NDS32_TLS_DESC_MEM},
3159 {BFD_RELOC_NDS32_REMOVE, R_NDS32_RELAX_REMOVE},
3160 {BFD_RELOC_NDS32_GROUP, R_NDS32_RELAX_GROUP},
3161 {BFD_RELOC_NDS32_LSI, R_NDS32_LSI},
3162 };
3163
3164 /* Patch tag. */
3165
3166 static reloc_howto_type *
3167 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
3168 const char *r_name)
3169 {
3170 unsigned int i;
3171
3172 for (i = 0; i < ARRAY_SIZE (nds32_elf_howto_table); i++)
3173 if (nds32_elf_howto_table[i].name != NULL
3174 && strcasecmp (nds32_elf_howto_table[i].name, r_name) == 0)
3175 return &nds32_elf_howto_table[i];
3176
3177 for (i = 0; i < ARRAY_SIZE (nds32_elf_relax_howto_table); i++)
3178 if (nds32_elf_relax_howto_table[i].name != NULL
3179 && strcasecmp (nds32_elf_relax_howto_table[i].name, r_name) == 0)
3180 return &nds32_elf_relax_howto_table[i];
3181
3182 return NULL;
3183 }
3184
3185 static reloc_howto_type *
3186 bfd_elf32_bfd_reloc_type_table_lookup (enum elf_nds32_reloc_type code)
3187 {
3188 if (code < R_NDS32_RELAX_ENTRY)
3189 {
3190 BFD_ASSERT (code < ARRAY_SIZE (nds32_elf_howto_table));
3191 return &nds32_elf_howto_table[code];
3192 }
3193 else
3194 {
3195 if ((size_t) (code - R_NDS32_RELAX_ENTRY)
3196 >= ARRAY_SIZE (nds32_elf_relax_howto_table))
3197 {
3198 int i = code;
3199 i += 1;
3200 }
3201
3202 BFD_ASSERT ((size_t) (code - R_NDS32_RELAX_ENTRY)
3203 < ARRAY_SIZE (nds32_elf_relax_howto_table));
3204 return &nds32_elf_relax_howto_table[code - R_NDS32_RELAX_ENTRY];
3205 }
3206 }
3207
3208 static reloc_howto_type *
3209 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
3210 bfd_reloc_code_real_type code)
3211 {
3212 unsigned int i;
3213
3214 for (i = 0; i < ARRAY_SIZE (nds32_reloc_map); i++)
3215 {
3216 if (nds32_reloc_map[i].bfd_reloc_val == code)
3217 return bfd_elf32_bfd_reloc_type_table_lookup
3218 (nds32_reloc_map[i].elf_reloc_val);
3219 }
3220
3221 return NULL;
3222 }
3223
3224 /* Set the howto pointer for an NDS32 ELF reloc. */
3225
3226 static bfd_boolean
3227 nds32_info_to_howto_rel (bfd *abfd, arelent *cache_ptr,
3228 Elf_Internal_Rela *dst)
3229 {
3230 enum elf_nds32_reloc_type r_type;
3231
3232 r_type = ELF32_R_TYPE (dst->r_info);
3233 if (r_type > R_NDS32_GNU_VTENTRY)
3234 {
3235 /* xgettext:c-format */
3236 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3237 abfd, r_type);
3238 bfd_set_error (bfd_error_bad_value);
3239 return FALSE;
3240 }
3241
3242 BFD_ASSERT (ELF32_R_TYPE (dst->r_info) <= R_NDS32_GNU_VTENTRY);
3243 cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
3244 return TRUE;
3245 }
3246
3247 static bfd_boolean
3248 nds32_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
3249 Elf_Internal_Rela *dst)
3250 {
3251 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
3252
3253 if ((r_type == R_NDS32_NONE)
3254 || ((r_type > R_NDS32_GNU_VTENTRY)
3255 && (r_type < R_NDS32_max)))
3256 {
3257 cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
3258 return TRUE;
3259 }
3260
3261 /* xgettext:c-format */
3262 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, r_type);
3263 bfd_set_error (bfd_error_bad_value);
3264 return FALSE;
3265 }
3266
3267 /* Support for core dump NOTE sections.
3268 Reference to include/linux/elfcore.h in Linux. */
3269
3270 static bfd_boolean
3271 nds32_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3272 {
3273 int offset;
3274 size_t size;
3275
3276 switch (note->descsz)
3277 {
3278 case 0x114:
3279 /* Linux/NDS32 32-bit, ABI1. */
3280
3281 /* pr_cursig */
3282 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3283
3284 /* pr_pid */
3285 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3286
3287 /* pr_reg */
3288 offset = 72;
3289 size = 200;
3290 break;
3291
3292 case 0xfc:
3293 /* Linux/NDS32 32-bit. */
3294
3295 /* pr_cursig */
3296 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3297
3298 /* pr_pid */
3299 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3300
3301 /* pr_reg */
3302 offset = 72;
3303 size = 176;
3304 break;
3305
3306 default:
3307 return FALSE;
3308 }
3309
3310 /* Make a ".reg" section. */
3311 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3312 size, note->descpos + offset);
3313 }
3314
3315 static bfd_boolean
3316 nds32_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3317 {
3318 switch (note->descsz)
3319 {
3320 case 124:
3321 /* Linux/NDS32. */
3322
3323 /* __kernel_uid_t, __kernel_gid_t are short on NDS32 platform. */
3324 elf_tdata (abfd)->core->program =
3325 _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
3326 elf_tdata (abfd)->core->command =
3327 _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
3328 break;
3329
3330 default:
3331 return FALSE;
3332 }
3333
3334 /* Note that for some reason, a spurious space is tacked
3335 onto the end of the args in some (at least one anyway)
3336 implementations, so strip it off if it exists. */
3337 {
3338 char *command = elf_tdata (abfd)->core->command;
3339 int n = strlen (command);
3340
3341 if (0 < n && command[n - 1] == ' ')
3342 command[n - 1] = '\0';
3343 }
3344
3345 return TRUE;
3346 }
3347
3348 /* Hook called by the linker routine which adds symbols from an object
3349 file. We must handle the special NDS32 section numbers here.
3350 We also keep watching for whether we need to create the sdata special
3351 linker sections. */
3352
3353 static bfd_boolean
3354 nds32_elf_add_symbol_hook (bfd *abfd,
3355 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3356 Elf_Internal_Sym *sym,
3357 const char **namep ATTRIBUTE_UNUSED,
3358 flagword *flagsp ATTRIBUTE_UNUSED,
3359 asection **secp, bfd_vma *valp)
3360 {
3361 switch (sym->st_shndx)
3362 {
3363 case SHN_COMMON:
3364 /* Common symbols less than the GP size are automatically
3365 treated as SHN_MIPS_SCOMMON symbols. */
3366 if (sym->st_size > elf_gp_size (abfd)
3367 || ELF_ST_TYPE (sym->st_info) == STT_TLS)
3368 break;
3369
3370 /* st_value is the alignemnt constraint.
3371 That might be its actual size if it is an array or structure. */
3372 switch (sym->st_value)
3373 {
3374 case 1:
3375 *secp = bfd_make_section_old_way (abfd, ".scommon_b");
3376 break;
3377 case 2:
3378 *secp = bfd_make_section_old_way (abfd, ".scommon_h");
3379 break;
3380 case 4:
3381 *secp = bfd_make_section_old_way (abfd, ".scommon_w");
3382 break;
3383 case 8:
3384 *secp = bfd_make_section_old_way (abfd, ".scommon_d");
3385 break;
3386 default:
3387 return TRUE;
3388 }
3389
3390 (*secp)->flags |= SEC_IS_COMMON;
3391 *valp = sym->st_size;
3392 break;
3393 }
3394
3395 return TRUE;
3396 }
3397
3398 /* This function can figure out the best location for a base register to access
3399 data relative to this base register
3400 INPUT:
3401 sda_d0: size of first DOUBLE WORD data section
3402 sda_w0: size of first WORD data section
3403 sda_h0: size of first HALF WORD data section
3404 sda_b : size of BYTE data section
3405 sda_hi: size of second HALF WORD data section
3406 sda_w1: size of second WORD data section
3407 sda_d1: size of second DOUBLE WORD data section
3408 OUTPUT:
3409 offset (always positive) from the beginning of sda_d0 if OK
3410 a negative error value if fail
3411 NOTE:
3412 these 7 sections have to be located back to back if exist
3413 a pass in 0 value for non-existing section */
3414
3415 /* Due to the interpretation of simm15 field of load/store depending on
3416 data accessing size, the organization of base register relative data shall
3417 like the following figure
3418 -------------------------------------------
3419 | DOUBLE WORD sized data (range +/- 128K)
3420 -------------------------------------------
3421 | WORD sized data (range +/- 64K)
3422 -------------------------------------------
3423 | HALF WORD sized data (range +/- 32K)
3424 -------------------------------------------
3425 | BYTE sized data (range +/- 16K)
3426 -------------------------------------------
3427 | HALF WORD sized data (range +/- 32K)
3428 -------------------------------------------
3429 | WORD sized data (range +/- 64K)
3430 -------------------------------------------
3431 | DOUBLE WORD sized data (range +/- 128K)
3432 -------------------------------------------
3433 Its base register shall be set to access these data freely. */
3434
3435 /* We have to figure out the SDA_BASE value, so that we can adjust the
3436 symbol value correctly. We look up the symbol _SDA_BASE_ in the output
3437 BFD. If we can't find it, we're stuck. We cache it in the ELF
3438 target data. We don't need to adjust the symbol value for an
3439 external symbol if we are producing relocatable output. */
3440
3441 static asection *sda_rela_sec = NULL;
3442
3443 #define SDA_SECTION_NUM 10
3444
3445 static bfd_reloc_status_type
3446 nds32_elf_final_sda_base (bfd * output_bfd,
3447 struct bfd_link_info * info,
3448 bfd_vma * psb,
3449 bfd_boolean add_symbol)
3450 {
3451 int relax_fp_as_gp;
3452 struct elf_nds32_link_hash_table *table;
3453 struct bfd_link_hash_entry *h, *h2;
3454 long unsigned int total = 0;
3455 asection *first = NULL, *final = NULL, *temp;
3456 bfd_vma sda_base = 0;
3457
3458 h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
3459 if (!h || (h->type != bfd_link_hash_defined
3460 && h->type != bfd_link_hash_defweak))
3461 {
3462 /* The first section must be 4-byte aligned to promise _SDA_BASE_ being
3463 4 byte-aligned. Therefore, it has to set the first section ".data"
3464 4 byte-aligned. */
3465 static const char sec_name[SDA_SECTION_NUM][10] =
3466 {
3467 ".data", ".got", ".sdata_d", ".sdata_w", ".sdata_h", ".sdata_b",
3468 ".sbss_b", ".sbss_h", ".sbss_w", ".sbss_d"
3469 };
3470 size_t i = 0;
3471
3472 if (output_bfd->sections == NULL)
3473 {
3474 *psb = elf_gp (output_bfd);
3475 return bfd_reloc_ok;
3476 }
3477
3478 /* Get the first and final section. */
3479 while (i < ARRAY_SIZE (sec_name))
3480 {
3481 temp = bfd_get_section_by_name (output_bfd, sec_name[i]);
3482 if (temp && !first && (temp->size != 0 || temp->rawsize != 0))
3483 first = temp;
3484 if (temp && (temp->size != 0 || temp->rawsize != 0))
3485 final = temp;
3486
3487 /* Summarize the sections in order to check if joining .bss. */
3488 if (temp && temp->size != 0)
3489 total += temp->size;
3490 else if (temp && temp->rawsize != 0)
3491 total += temp->rawsize;
3492
3493 i++;
3494 }
3495
3496 /* Check .bss size. */
3497 temp = bfd_get_section_by_name (output_bfd, ".bss");
3498 if (temp)
3499 {
3500 if (temp->size != 0)
3501 total += temp->size;
3502 else if (temp->rawsize != 0)
3503 total += temp->rawsize;
3504
3505 if (total < 0x80000)
3506 {
3507 if (!first && (temp->size != 0 || temp->rawsize != 0))
3508 first = temp;
3509 if ((temp->size != 0 || temp->rawsize != 0))
3510 final = temp;
3511 }
3512 }
3513
3514 if (first && final)
3515 {
3516 /* The middle of data region. */
3517 sda_base = final->vma / 2 + final->rawsize / 2 + first->vma / 2;
3518
3519 /* Find the section sda_base located. */
3520 i = 0;
3521 while (i < ARRAY_SIZE (sec_name))
3522 {
3523 final = bfd_get_section_by_name (output_bfd, sec_name[i]);
3524 if (final && (final->size != 0 || final->rawsize != 0)
3525 && sda_base >= final->vma)
3526 {
3527 first = final;
3528 i++;
3529 }
3530 else
3531 break;
3532 }
3533 }
3534 else
3535 {
3536 /* If there is not any default data section in output bfd, try to find
3537 the first data section. If no data section be found, just simplily
3538 choose the first output section. */
3539 temp = output_bfd->sections;
3540 while (temp)
3541 {
3542 if (temp->flags & SEC_ALLOC
3543 && (((temp->flags & SEC_DATA)
3544 && ((temp->flags & SEC_READONLY) == 0))
3545 || (temp->flags & SEC_LOAD) == 0)
3546 && (temp->size != 0 || temp->rawsize != 0))
3547 {
3548 if (!first)
3549 first = temp;
3550 final = temp;
3551 }
3552 temp = temp->next;
3553 }
3554
3555 /* There is no data or bss section. */
3556 if (!first || (first->size == 0 && first->rawsize == 0))
3557 {
3558 first = output_bfd->sections;
3559 while (first && first->size == 0 && first->rawsize == 0)
3560 first = first->next;
3561 }
3562
3563 /* There is no concrete section. */
3564 if (!first)
3565 {
3566 *psb = elf_gp (output_bfd);
3567 return bfd_reloc_ok;
3568 }
3569
3570 if (final && (final->vma + final->rawsize - first->vma) <= 0x4000)
3571 sda_base = final->vma / 2 + final->rawsize / 2 + first->vma / 2;
3572 else
3573 sda_base = first->vma + 0x2000;
3574 }
3575
3576 sda_base -= first->vma;
3577 sda_base = sda_base & (~7);
3578
3579 if (!_bfd_generic_link_add_one_symbol
3580 (info, output_bfd, "_SDA_BASE_", BSF_GLOBAL | BSF_WEAK, first,
3581 (bfd_vma) sda_base, (const char *) NULL, FALSE,
3582 get_elf_backend_data (output_bfd)->collect, &h))
3583 return FALSE;
3584
3585 sda_rela_sec = first;
3586 }
3587
3588 /* Set _FP_BASE_ to _SDA_BASE_. */
3589 table = nds32_elf_hash_table (info);
3590 relax_fp_as_gp = table->relax_fp_as_gp;
3591 h2 = bfd_link_hash_lookup (info->hash, FP_BASE_NAME, FALSE, FALSE, FALSE);
3592 /* _SDA_BASE_ is difined in linker script. */
3593 if (!first)
3594 {
3595 first = h->u.def.section;
3596 sda_base = h->u.def.value;
3597 }
3598
3599 if (relax_fp_as_gp && h2
3600 && (h2->type == bfd_link_hash_undefweak
3601 || h2->type == bfd_link_hash_undefined))
3602 {
3603 /* Define a weak FP_BASE_NAME here to prevent the undefined symbol.
3604 And set FP equal to SDA_BASE to do relaxation for
3605 la $fp, _FP_BASE_. */
3606 if (!_bfd_generic_link_add_one_symbol
3607 (info, output_bfd, FP_BASE_NAME, BSF_GLOBAL | BSF_WEAK,
3608 first, sda_base, (const char *) NULL,
3609 FALSE, get_elf_backend_data (output_bfd)->collect, &h2))
3610 return FALSE;
3611 }
3612
3613 if (add_symbol)
3614 {
3615 if (h)
3616 {
3617 /* Now set gp. */
3618 elf_gp (output_bfd) = (h->u.def.value
3619 + h->u.def.section->output_section->vma
3620 + h->u.def.section->output_offset);
3621 }
3622 else
3623 {
3624 _bfd_error_handler (_("error: can't find symbol: %s"), "_SDA_BASE_");
3625 return bfd_reloc_dangerous;
3626 }
3627 }
3628
3629 *psb = h->u.def.value
3630 + h->u.def.section->output_section->vma
3631 + h->u.def.section->output_offset;
3632 return bfd_reloc_ok;
3633 }
3634 \f
3635
3636 /* Return size of a PLT entry. */
3637 #define elf_nds32_sizeof_plt(info) PLT_ENTRY_SIZE
3638
3639 /* Create an entry in an nds32 ELF linker hash table. */
3640
3641 static struct bfd_hash_entry *
3642 nds32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
3643 struct bfd_hash_table *table,
3644 const char *string)
3645 {
3646 struct elf_nds32_link_hash_entry *ret;
3647
3648 ret = (struct elf_nds32_link_hash_entry *) entry;
3649
3650 /* Allocate the structure if it has not already been allocated by a
3651 subclass. */
3652 if (ret == NULL)
3653 ret = (struct elf_nds32_link_hash_entry *)
3654 bfd_hash_allocate (table, sizeof (struct elf_nds32_link_hash_entry));
3655
3656 if (ret == NULL)
3657 return (struct bfd_hash_entry *) ret;
3658
3659 /* Call the allocation method of the superclass. */
3660 ret = (struct elf_nds32_link_hash_entry *)
3661 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);
3662
3663 if (ret != NULL)
3664 {
3665 struct elf_nds32_link_hash_entry *eh;
3666
3667 eh = (struct elf_nds32_link_hash_entry *) ret;
3668 eh->dyn_relocs = NULL;
3669 eh->tls_type = GOT_UNKNOWN;
3670 eh->offset_to_gp = 0;
3671 }
3672
3673 return (struct bfd_hash_entry *) ret;
3674 }
3675
3676 /* Create an nds32 ELF linker hash table. */
3677
3678 static struct bfd_link_hash_table *
3679 nds32_elf_link_hash_table_create (bfd *abfd)
3680 {
3681 struct elf_nds32_link_hash_table *ret;
3682
3683 bfd_size_type amt = sizeof (struct elf_nds32_link_hash_table);
3684
3685 ret = (struct elf_nds32_link_hash_table *) bfd_zmalloc (amt);
3686 if (ret == NULL)
3687 return NULL;
3688
3689 /* Patch tag. */
3690 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3691 nds32_elf_link_hash_newfunc,
3692 sizeof (struct elf_nds32_link_hash_entry),
3693 NDS32_ELF_DATA))
3694 {
3695 free (ret);
3696 return NULL;
3697 }
3698
3699 ret->sdynbss = NULL;
3700 ret->srelbss = NULL;
3701 ret->sym_ld_script = NULL;
3702
3703 return &ret->root.root;
3704 }
3705
3706 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
3707 shortcuts to them in our hash table. */
3708
3709 static bfd_boolean
3710 create_got_section (bfd *dynobj, struct bfd_link_info *info)
3711 {
3712 struct elf_link_hash_table *ehtab;
3713
3714 if (!_bfd_elf_create_got_section (dynobj, info))
3715 return FALSE;
3716
3717 ehtab = elf_hash_table (info);
3718 ehtab->sgot = bfd_get_section_by_name (dynobj, ".got");
3719 ehtab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
3720 if (!ehtab->sgot || !ehtab->sgotplt)
3721 abort ();
3722
3723 /* _bfd_elf_create_got_section will create it for us. */
3724 ehtab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3725 if (ehtab->srelgot == NULL
3726 || !bfd_set_section_flags (dynobj, ehtab->srelgot,
3727 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
3728 | SEC_IN_MEMORY | SEC_LINKER_CREATED
3729 | SEC_READONLY))
3730 || !bfd_set_section_alignment (dynobj, ehtab->srelgot, 2))
3731 return FALSE;
3732
3733 return TRUE;
3734 }
3735
3736 /* Create dynamic sections when linking against a dynamic object. */
3737
3738 static bfd_boolean
3739 nds32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3740 {
3741 struct elf_link_hash_table *ehtab;
3742 struct elf_nds32_link_hash_table *htab;
3743 flagword flags, pltflags;
3744 register asection *s;
3745 const struct elf_backend_data *bed;
3746 int ptralign = 2; /* 32-bit */
3747 const char *secname;
3748 char *relname;
3749 flagword secflags;
3750 asection *sec;
3751
3752 bed = get_elf_backend_data (abfd);
3753 ehtab = elf_hash_table (info);
3754 htab = nds32_elf_hash_table (info);
3755
3756 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3757 .rel[a].bss sections. */
3758
3759 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3760 | SEC_LINKER_CREATED);
3761
3762 pltflags = flags;
3763 pltflags |= SEC_CODE;
3764 if (bed->plt_not_loaded)
3765 pltflags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
3766 if (bed->plt_readonly)
3767 pltflags |= SEC_READONLY;
3768
3769 s = bfd_make_section (abfd, ".plt");
3770 ehtab->splt = s;
3771 if (s == NULL
3772 || !bfd_set_section_flags (abfd, s, pltflags)
3773 || !bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3774 return FALSE;
3775
3776 if (bed->want_plt_sym)
3777 {
3778 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3779 .plt section. */
3780 struct bfd_link_hash_entry *bh = NULL;
3781 struct elf_link_hash_entry *h;
3782
3783 if (!(_bfd_generic_link_add_one_symbol
3784 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3785 (bfd_vma) 0, (const char *) NULL, FALSE,
3786 get_elf_backend_data (abfd)->collect, &bh)))
3787 return FALSE;
3788
3789 h = (struct elf_link_hash_entry *) bh;
3790 h->def_regular = 1;
3791 h->type = STT_OBJECT;
3792
3793 if (bfd_link_pic (info) && !bfd_elf_link_record_dynamic_symbol (info, h))
3794 return FALSE;
3795 }
3796
3797 s = bfd_make_section (abfd,
3798 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
3799 ehtab->srelplt = s;
3800 if (s == NULL
3801 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3802 || !bfd_set_section_alignment (abfd, s, ptralign))
3803 return FALSE;
3804
3805 if (ehtab->sgot == NULL && !create_got_section (abfd, info))
3806 return FALSE;
3807
3808 for (sec = abfd->sections; sec; sec = sec->next)
3809 {
3810 secflags = bfd_get_section_flags (abfd, sec);
3811 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3812 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3813 continue;
3814 secname = bfd_get_section_name (abfd, sec);
3815 relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
3816 strcpy (relname, ".rela");
3817 strcat (relname, secname);
3818 if (bfd_get_section_by_name (abfd, secname))
3819 continue;
3820 s = bfd_make_section (abfd, relname);
3821 if (s == NULL
3822 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3823 || !bfd_set_section_alignment (abfd, s, ptralign))
3824 return FALSE;
3825 }
3826
3827 if (bed->want_dynbss)
3828 {
3829 /* The .dynbss section is a place to put symbols which are defined
3830 by dynamic objects, are referenced by regular objects, and are
3831 not functions. We must allocate space for them in the process
3832 image and use a R_*_COPY reloc to tell the dynamic linker to
3833 initialize them at run time. The linker script puts the .dynbss
3834 section into the .bss section of the final image. */
3835 s = bfd_make_section (abfd, ".dynbss");
3836 htab->sdynbss = s;
3837 if (s == NULL
3838 || !bfd_set_section_flags (abfd, s, SEC_ALLOC | SEC_LINKER_CREATED))
3839 return FALSE;
3840 /* The .rel[a].bss section holds copy relocs. This section is not
3841 normally needed. We need to create it here, though, so that the
3842 linker will map it to an output section. We can't just create it
3843 only if we need it, because we will not know whether we need it
3844 until we have seen all the input files, and the first time the
3845 main linker code calls BFD after examining all the input files
3846 (size_dynamic_sections) the input sections have already been
3847 mapped to the output sections. If the section turns out not to
3848 be needed, we can discard it later. We will never need this
3849 section when generating a shared object, since they do not use
3850 copy relocs. */
3851 if (!bfd_link_pic (info))
3852 {
3853 s = bfd_make_section (abfd, (bed->default_use_rela_p
3854 ? ".rela.bss" : ".rel.bss"));
3855 htab->srelbss = s;
3856 if (s == NULL
3857 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3858 || !bfd_set_section_alignment (abfd, s, ptralign))
3859 return FALSE;
3860 }
3861 }
3862
3863 return TRUE;
3864 }
3865
3866 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3867 static void
3868 nds32_elf_copy_indirect_symbol (struct bfd_link_info *info,
3869 struct elf_link_hash_entry *dir,
3870 struct elf_link_hash_entry *ind)
3871 {
3872 struct elf_nds32_link_hash_entry *edir, *eind;
3873
3874 edir = (struct elf_nds32_link_hash_entry *) dir;
3875 eind = (struct elf_nds32_link_hash_entry *) ind;
3876
3877 if (eind->dyn_relocs != NULL)
3878 {
3879 if (edir->dyn_relocs != NULL)
3880 {
3881 struct elf_dyn_relocs **pp;
3882 struct elf_dyn_relocs *p;
3883
3884 if (ind->root.type == bfd_link_hash_indirect)
3885 abort ();
3886
3887 /* Add reloc counts against the weak sym to the strong sym
3888 list. Merge any entries against the same section. */
3889 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
3890 {
3891 struct elf_dyn_relocs *q;
3892
3893 for (q = edir->dyn_relocs; q != NULL; q = q->next)
3894 if (q->sec == p->sec)
3895 {
3896 q->pc_count += p->pc_count;
3897 q->count += p->count;
3898 *pp = p->next;
3899 break;
3900 }
3901 if (q == NULL)
3902 pp = &p->next;
3903 }
3904 *pp = edir->dyn_relocs;
3905 }
3906
3907 edir->dyn_relocs = eind->dyn_relocs;
3908 eind->dyn_relocs = NULL;
3909 }
3910
3911 if (ind->root.type == bfd_link_hash_indirect)
3912 {
3913 if (dir->got.refcount <= 0)
3914 {
3915 edir->tls_type = eind->tls_type;
3916 eind->tls_type = GOT_UNKNOWN;
3917 }
3918 }
3919
3920 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3921 }
3922 \f
3923
3924 /* Find dynamic relocs for H that apply to read-only sections. */
3925
3926 static asection *
3927 readonly_dynrelocs (struct elf_link_hash_entry *h)
3928 {
3929 struct elf_dyn_relocs *p;
3930
3931 for (p = elf32_nds32_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
3932 {
3933 asection *s = p->sec->output_section;
3934
3935 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3936 return p->sec;
3937 }
3938 return NULL;
3939 }
3940
3941 /* Adjust a symbol defined by a dynamic object and referenced by a
3942 regular object. The current definition is in some section of the
3943 dynamic object, but we're not including those sections. We have to
3944 change the definition to something the rest of the link can
3945 understand. */
3946
3947 static bfd_boolean
3948 nds32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
3949 struct elf_link_hash_entry *h)
3950 {
3951 struct elf_nds32_link_hash_table *htab;
3952 bfd *dynobj;
3953 asection *s;
3954 unsigned int power_of_two;
3955
3956 dynobj = elf_hash_table (info)->dynobj;
3957
3958 /* Make sure we know what is going on here. */
3959 BFD_ASSERT (dynobj != NULL
3960 && (h->needs_plt
3961 || h->is_weakalias
3962 || (h->def_dynamic && h->ref_regular && !h->def_regular)));
3963
3964
3965 /* If this is a function, put it in the procedure linkage table. We
3966 will fill in the contents of the procedure linkage table later,
3967 when we know the address of the .got section. */
3968 if (h->type == STT_FUNC || h->needs_plt)
3969 {
3970 if (!bfd_link_pic (info)
3971 && !h->def_dynamic
3972 && !h->ref_dynamic
3973 && h->root.type != bfd_link_hash_undefweak
3974 && h->root.type != bfd_link_hash_undefined)
3975 {
3976 /* This case can occur if we saw a PLT reloc in an input
3977 file, but the symbol was never referred to by a dynamic
3978 object. In such a case, we don't actually need to build
3979 a procedure linkage table, and we can just do a PCREL
3980 reloc instead. */
3981 h->plt.offset = (bfd_vma) - 1;
3982 h->needs_plt = 0;
3983 }
3984
3985 return TRUE;
3986 }
3987 else
3988 h->plt.offset = (bfd_vma) - 1;
3989
3990 /* If this is a weak symbol, and there is a real definition, the
3991 processor independent code will have arranged for us to see the
3992 real definition first, and we can just use the same value. */
3993 if (h->is_weakalias)
3994 {
3995 struct elf_link_hash_entry *def = weakdef (h);
3996 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
3997 h->root.u.def.section = def->root.u.def.section;
3998 h->root.u.def.value = def->root.u.def.value;
3999 return TRUE;
4000 }
4001
4002 /* This is a reference to a symbol defined by a dynamic object which
4003 is not a function. */
4004
4005 /* If we are creating a shared library, we must presume that the
4006 only references to the symbol are via the global offset table.
4007 For such cases we need not do anything here; the relocations will
4008 be handled correctly by relocate_section. */
4009 if (bfd_link_pic (info))
4010 return TRUE;
4011
4012 /* If there are no references to this symbol that do not use the
4013 GOT, we don't need to generate a copy reloc. */
4014 if (!h->non_got_ref)
4015 return TRUE;
4016
4017 /* If -z nocopyreloc was given, we won't generate them either. */
4018 if (0 && info->nocopyreloc)
4019 {
4020 h->non_got_ref = 0;
4021 return TRUE;
4022 }
4023
4024 /* If we don't find any dynamic relocs in read-only sections, then
4025 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
4026 if (!readonly_dynrelocs (h))
4027 {
4028 h->non_got_ref = 0;
4029 return TRUE;
4030 }
4031
4032 /* We must allocate the symbol in our .dynbss section, which will
4033 become part of the .bss section of the executable. There will be
4034 an entry for this symbol in the .dynsym section. The dynamic
4035 object will contain position independent code, so all references
4036 from the dynamic object to this symbol will go through the global
4037 offset table. The dynamic linker will use the .dynsym entry to
4038 determine the address it must put in the global offset table, so
4039 both the dynamic object and the regular object will refer to the
4040 same memory location for the variable. */
4041
4042 htab = nds32_elf_hash_table (info);
4043 s = htab->sdynbss;
4044 BFD_ASSERT (s != NULL);
4045
4046 /* We must generate a R_NDS32_COPY reloc to tell the dynamic linker
4047 to copy the initial value out of the dynamic object and into the
4048 runtime process image. We need to remember the offset into the
4049 .rela.bss section we are going to use. */
4050 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4051 {
4052 asection *srel;
4053
4054 srel = htab->srelbss;
4055 BFD_ASSERT (srel != NULL);
4056 srel->size += sizeof (Elf32_External_Rela);
4057 h->needs_copy = 1;
4058 }
4059
4060 /* We need to figure out the alignment required for this symbol. I
4061 have no idea how ELF linkers handle this. */
4062 power_of_two = bfd_log2 (h->size);
4063 if (power_of_two > 3)
4064 power_of_two = 3;
4065
4066 /* Apply the required alignment. */
4067 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
4068 if (power_of_two > bfd_get_section_alignment (dynobj, s))
4069 {
4070 if (!bfd_set_section_alignment (dynobj, s, power_of_two))
4071 return FALSE;
4072 }
4073
4074 /* Define the symbol as being at this point in the section. */
4075 h->root.u.def.section = s;
4076 h->root.u.def.value = s->size;
4077
4078 /* Increment the section size to make room for the symbol. */
4079 s->size += h->size;
4080
4081 return TRUE;
4082 }
4083
4084 /* Allocate space in .plt, .got and associated reloc sections for
4085 dynamic relocs. */
4086
4087 static bfd_boolean
4088 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
4089 {
4090 struct bfd_link_info *info;
4091 struct elf_link_hash_table *ehtab;
4092 struct elf_nds32_link_hash_table *htab;
4093 struct elf_nds32_link_hash_entry *eh;
4094 struct elf_dyn_relocs *p;
4095
4096 if (h->root.type == bfd_link_hash_indirect)
4097 return TRUE;
4098
4099 /* When warning symbols are created, they **replace** the "real"
4100 entry in the hash table, thus we never get to see the real
4101 symbol in a hash traversal. So look at it now. */
4102 if (h->root.type == bfd_link_hash_warning)
4103 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4104
4105 eh = (struct elf_nds32_link_hash_entry *) h;
4106
4107 info = (struct bfd_link_info *) inf;
4108 ehtab = elf_hash_table (info);
4109 htab = nds32_elf_hash_table (info);
4110 if (htab == NULL)
4111 return FALSE;
4112
4113 eh = (struct elf_nds32_link_hash_entry *) h;
4114
4115 if ((htab->root.dynamic_sections_created || h->type == STT_GNU_IFUNC)
4116 && h->plt.refcount > 0
4117 && !(bfd_link_pie (info) && h->def_regular))
4118 {
4119 /* Make sure this symbol is output as a dynamic symbol.
4120 Undefined weak syms won't yet be marked as dynamic. */
4121 if (h->dynindx == -1 && !h->forced_local)
4122 {
4123 if (!bfd_elf_link_record_dynamic_symbol (info, h))
4124 return FALSE;
4125 }
4126
4127 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
4128 {
4129 asection *s = ehtab->splt;
4130
4131 /* If this is the first .plt entry, make room for the special
4132 first entry. */
4133 if (s->size == 0)
4134 s->size += PLT_ENTRY_SIZE;
4135
4136 h->plt.offset = s->size;
4137
4138 /* If this symbol is not defined in a regular file, and we are
4139 not generating a shared library, then set the symbol to this
4140 location in the .plt. This is required to make function
4141 pointers compare as equal between the normal executable and
4142 the shared library. */
4143 if (!bfd_link_pic (info) && !h->def_regular)
4144 {
4145 h->root.u.def.section = s;
4146 h->root.u.def.value = h->plt.offset;
4147 }
4148
4149 /* Make room for this entry. */
4150 s->size += PLT_ENTRY_SIZE;
4151
4152 /* We also need to make an entry in the .got.plt section, which
4153 will be placed in the .got section by the linker script. */
4154 ehtab->sgotplt->size += 4;
4155
4156 /* We also need to make an entry in the .rel.plt section. */
4157 ehtab->srelplt->size += sizeof (Elf32_External_Rela);
4158 if (htab->tls_desc_trampoline)
4159 htab->next_tls_desc_index++;
4160 }
4161 else
4162 {
4163 h->plt.offset = (bfd_vma) - 1;
4164 h->needs_plt = 0;
4165 }
4166 }
4167 else
4168 {
4169 h->plt.offset = (bfd_vma) - 1;
4170 h->needs_plt = 0;
4171 }
4172
4173 if (h->got.refcount > 0)
4174 {
4175 asection *sgot;
4176 bfd_boolean dyn;
4177 int tls_type = elf32_nds32_hash_entry (h)->tls_type;
4178
4179 /* Make sure this symbol is output as a dynamic symbol.
4180 Undefined weak syms won't yet be marked as dynamic. */
4181 if (h->dynindx == -1 && !h->forced_local)
4182 {
4183 if (!bfd_elf_link_record_dynamic_symbol (info, h))
4184 return FALSE;
4185 }
4186
4187 sgot = elf_hash_table (info)->sgot;
4188 h->got.offset = sgot->size;
4189
4190 if (tls_type == GOT_UNKNOWN)
4191 abort ();
4192
4193 /* Non-TLS symbols, and TLS_IE need one GOT slot. */
4194 if (tls_type & (GOT_NORMAL | GOT_TLS_IE | GOT_TLS_IEGP))
4195 sgot->size += 4;
4196 else
4197 {
4198 /* TLS_DESC, TLS_GD, and TLS_LD need 2 consecutive GOT slots. */
4199 if (tls_type & GOT_TLS_DESC)
4200 sgot->size += 8;
4201 }
4202
4203 dyn = htab->root.dynamic_sections_created;
4204
4205 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
4206 {
4207 if (tls_type == GOT_TLS_DESC && htab->tls_desc_trampoline)
4208 {
4209 /* TLS_DESC with trampoline needs a relocation slot
4210 within .rela.plt. */
4211 htab->num_tls_desc++;
4212 ehtab->srelplt->size += sizeof (Elf32_External_Rela);
4213 htab->tls_trampoline = -1;
4214 }
4215 else
4216 {
4217 /* other relocations, including TLS_DESC without trampoline, need
4218 a relocation slot within .rela.got. */
4219 ehtab->srelgot->size += sizeof (Elf32_External_Rela);
4220 }
4221 }
4222 }
4223 else
4224 h->got.offset = (bfd_vma)-1;
4225
4226 if (eh->dyn_relocs == NULL)
4227 return TRUE;
4228
4229 /* In the shared -Bsymbolic case, discard space allocated for
4230 dynamic pc-relative relocs against symbols which turn out to be
4231 defined in regular objects. For the normal shared case, discard
4232 space for pc-relative relocs that have become local due to symbol
4233 visibility changes. */
4234
4235 if (bfd_link_pic (info))
4236 {
4237 if (h->def_regular && (h->forced_local || info->symbolic))
4238 {
4239 struct elf_dyn_relocs **pp;
4240
4241 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
4242 {
4243 p->count -= p->pc_count;
4244 p->pc_count = 0;
4245 if (p->count == 0)
4246 *pp = p->next;
4247 else
4248 pp = &p->next;
4249 }
4250 }
4251 }
4252 else
4253 {
4254 /* For the non-shared case, discard space for relocs against
4255 symbols which turn out to need copy relocs or are not dynamic. */
4256
4257 if (!h->non_got_ref
4258 && ((h->def_dynamic
4259 && !h->def_regular)
4260 || (htab->root.dynamic_sections_created
4261 && (h->root.type == bfd_link_hash_undefweak
4262 || h->root.type == bfd_link_hash_undefined))))
4263 {
4264 /* Make sure this symbol is output as a dynamic symbol.
4265 Undefined weak syms won't yet be marked as dynamic. */
4266 if (h->dynindx == -1 && !h->forced_local)
4267 {
4268 if (!bfd_elf_link_record_dynamic_symbol (info, h))
4269 return FALSE;
4270 }
4271
4272 /* If that succeeded, we know we'll be keeping all the
4273 relocs. */
4274 if (h->dynindx != -1)
4275 goto keep;
4276 }
4277
4278 eh->dyn_relocs = NULL;
4279
4280 keep:;
4281 }
4282
4283 /* Finally, allocate space. */
4284 for (p = eh->dyn_relocs; p != NULL; p = p->next)
4285 {
4286 asection *sreloc = elf_section_data (p->sec)->sreloc;
4287 sreloc->size += p->count * sizeof (Elf32_External_Rela);
4288 }
4289
4290 return TRUE;
4291 }
4292
4293 /* Add relocation REL to the end of relocation section SRELOC. */
4294
4295 static void
4296 elf32_nds32_add_dynreloc (bfd *output_bfd,
4297 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4298 asection *sreloc, Elf_Internal_Rela *rel)
4299 {
4300 bfd_byte *loc;
4301 if (sreloc == NULL)
4302 abort ();
4303
4304 loc = sreloc->contents;
4305 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4306 if (sreloc->reloc_count * sizeof (Elf32_External_Rela) > sreloc->size)
4307 abort ();
4308
4309 bfd_elf32_swap_reloca_out (output_bfd, rel, loc);
4310 }
4311
4312 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
4313 read-only sections. */
4314
4315 static bfd_boolean
4316 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
4317 {
4318 asection *sec;
4319
4320 if (h->root.type == bfd_link_hash_indirect)
4321 return TRUE;
4322
4323 sec = readonly_dynrelocs (h);
4324 if (sec != NULL)
4325 {
4326 struct bfd_link_info *info = (struct bfd_link_info *) info_p;
4327
4328 info->flags |= DF_TEXTREL;
4329 info->callbacks->minfo
4330 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
4331 sec->owner, h->root.root.string, sec);
4332
4333 /* Not an error, just cut short the traversal. */
4334 return FALSE;
4335 }
4336 return TRUE;
4337 }
4338
4339 /* Set the sizes of the dynamic sections. */
4340
4341 static bfd_boolean
4342 nds32_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
4343 struct bfd_link_info *info)
4344 {
4345 struct elf_nds32_link_hash_table *htab;
4346 bfd *dynobj;
4347 asection *s;
4348 bfd_boolean relocs;
4349 bfd_boolean plt;
4350 bfd *ibfd;
4351
4352 htab = nds32_elf_hash_table (info);
4353 if (htab == NULL)
4354 return FALSE;
4355
4356 dynobj = elf_hash_table (info)->dynobj;
4357 BFD_ASSERT (dynobj != NULL);
4358
4359 if (elf_hash_table (info)->dynamic_sections_created)
4360 {
4361 /* Set the contents of the .interp section to the interpreter. */
4362 if (bfd_link_executable (info) && !info->nointerp)
4363 {
4364 s = bfd_get_section_by_name (dynobj, ".interp");
4365 BFD_ASSERT (s != NULL);
4366 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
4367 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4368 }
4369 }
4370
4371 /* Set up .got offsets for local syms, and space for local dynamic
4372 relocs. */
4373 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
4374 {
4375 bfd_signed_vma *local_got;
4376 bfd_signed_vma *end_local_got;
4377 bfd_size_type locsymcount;
4378 Elf_Internal_Shdr *symtab_hdr;
4379 asection *sgot;
4380 char *local_tls_type;
4381 unsigned long symndx;
4382 bfd_vma *local_tlsdesc_gotent;
4383
4384 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
4385 continue;
4386
4387 for (s = ibfd->sections; s != NULL; s = s->next)
4388 {
4389 struct elf_dyn_relocs *p;
4390
4391 for (p = ((struct elf_dyn_relocs *)
4392 elf_section_data (s)->local_dynrel);
4393 p != NULL; p = p->next)
4394 {
4395 if (!bfd_is_abs_section (p->sec)
4396 && bfd_is_abs_section (p->sec->output_section))
4397 {
4398 /* Input section has been discarded, either because
4399 it is a copy of a linkonce section or due to
4400 linker script /DISCARD/, so we'll be discarding
4401 the relocs too. */
4402 }
4403 else if (p->count != 0)
4404 {
4405 asection *sreloc = elf_section_data (p->sec)->sreloc;
4406 sreloc->size += p->count * sizeof (Elf32_External_Rela);
4407 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
4408 info->flags |= DF_TEXTREL;
4409 }
4410 }
4411 }
4412
4413 local_got = elf_local_got_refcounts (ibfd);
4414 if (!local_got)
4415 continue;
4416
4417 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4418 locsymcount = symtab_hdr->sh_info;
4419 end_local_got = local_got + locsymcount;
4420 sgot = elf_hash_table (info)->sgot;
4421 local_tls_type = elf32_nds32_local_got_tls_type (ibfd);
4422 local_tlsdesc_gotent = elf32_nds32_local_tlsdesc_gotent (ibfd);
4423 for (symndx = 0; local_got < end_local_got;
4424 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent, ++symndx)
4425 {
4426 if (*local_got > 0)
4427 {
4428 int num_of_got_entry_needed = 0;
4429 *local_got = sgot->size;
4430 *local_tlsdesc_gotent = sgot->size;
4431
4432 /* TLS_NORMAL, and TLS_IE need one slot in .got. */
4433 if (*local_tls_type & (GOT_NORMAL | GOT_TLS_IE | GOT_TLS_IEGP))
4434 num_of_got_entry_needed = 1;
4435 /* TLS_GD, TLS_LD, and TLS_DESC need an 8-byte structure in the GOT. */
4436 else if (*local_tls_type & GOT_TLS_DESC)
4437 num_of_got_entry_needed = 2;
4438
4439 sgot->size += (num_of_got_entry_needed << 2);
4440
4441 /* non-relax-able TLS_DESCs need a slot in .rela.plt.
4442 others need a slot in .rela.got. */
4443 if (*local_tls_type == GOT_TLS_DESC)
4444 {
4445 if (bfd_link_pic (info))
4446 {
4447 if (htab->tls_desc_trampoline)
4448 {
4449 htab->num_tls_desc++;
4450 htab->root.srelplt->size += sizeof (Elf32_External_Rela);
4451 htab->tls_trampoline = -1;
4452 }
4453 else
4454 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
4455 }
4456 else
4457 {
4458 /* TLS_DESC -> TLS_LE */
4459 }
4460 }
4461 else
4462 {
4463 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
4464 }
4465 }
4466 else
4467 {
4468 *local_got = (bfd_vma) -1;
4469 *local_tlsdesc_gotent = (bfd_vma) -1;
4470 }
4471 }
4472 }
4473
4474 /* Allocate global sym .plt and .got entries, and space for global
4475 sym dynamic relocs. */
4476 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (void *) info);
4477
4478 /* For every jump slot reserved in the sgotplt, reloc_count is
4479 incremented. However, when we reserve space for TLS descriptors,
4480 it's not incremented, so in order to compute the space reserved
4481 for them, it suffices to multiply the reloc count by the jump
4482 slot size. */
4483 if (htab->tls_desc_trampoline && htab->root.srelplt)
4484 htab->sgotplt_jump_table_size = elf32_nds32_compute_jump_table_size (htab);
4485
4486 if (htab->tls_trampoline)
4487 {
4488 htab->tls_trampoline = htab->root.splt->size;
4489
4490 /* If we're not using lazy TLS relocations, don't generate the
4491 PLT and GOT entries they require. */
4492 if (!(info->flags & DF_BIND_NOW))
4493 {
4494 htab->dt_tlsdesc_got = htab->root.sgot->size;
4495 htab->root.sgot->size += 4;
4496
4497 htab->dt_tlsdesc_plt = htab->root.splt->size;
4498 htab->root.splt->size += 4 * ARRAY_SIZE (dl_tlsdesc_lazy_trampoline);
4499 }
4500 }
4501
4502 /* We now have determined the sizes of the various dynamic sections.
4503 Allocate memory for them. */
4504 /* The check_relocs and adjust_dynamic_symbol entry points have
4505 determined the sizes of the various dynamic sections. Allocate
4506 memory for them. */
4507 plt = FALSE;
4508 relocs = FALSE;
4509 for (s = dynobj->sections; s != NULL; s = s->next)
4510 {
4511 if ((s->flags & SEC_LINKER_CREATED) == 0)
4512 continue;
4513
4514 if (s == htab->root.splt)
4515 {
4516 /* Strip this section if we don't need it; see the
4517 comment below. */
4518 plt = s->size != 0;
4519 }
4520 else if (s == elf_hash_table (info)->sgot)
4521 {
4522 got_size += s->size;
4523 }
4524 else if (s == elf_hash_table (info)->sgotplt)
4525 {
4526 got_size += s->size;
4527 }
4528 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
4529 {
4530 if (s->size != 0 && s != elf_hash_table (info)->srelplt)
4531 relocs = TRUE;
4532
4533 /* We use the reloc_count field as a counter if we need
4534 to copy relocs into the output file. */
4535 s->reloc_count = 0;
4536 }
4537 else
4538 {
4539 /* It's not one of our sections, so don't allocate space. */
4540 continue;
4541 }
4542
4543 if (s->size == 0)
4544 {
4545 /* If we don't need this section, strip it from the
4546 output file. This is mostly to handle .rela.bss and
4547 .rela.plt. We must create both sections in
4548 create_dynamic_sections, because they must be created
4549 before the linker maps input sections to output
4550 sections. The linker does that before
4551 adjust_dynamic_symbol is called, and it is that
4552 function which decides whether anything needs to go
4553 into these sections. */
4554 s->flags |= SEC_EXCLUDE;
4555 continue;
4556 }
4557
4558 /* Allocate memory for the section contents. We use bfd_zalloc
4559 here in case unused entries are not reclaimed before the
4560 section's contents are written out. This should not happen,
4561 but this way if it does, we get a R_NDS32_NONE reloc instead
4562 of garbage. */
4563 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
4564 if (s->contents == NULL)
4565 return FALSE;
4566 }
4567
4568
4569 if (htab->root.dynamic_sections_created)
4570 {
4571 /* Add some entries to the .dynamic section. We fill in the
4572 values later, in nds32_elf_finish_dynamic_sections, but we
4573 must add the entries now so that we get the correct size for
4574 the .dynamic section. The DT_DEBUG entry is filled in by the
4575 dynamic linker and used by the debugger. */
4576 #define add_dynamic_entry(TAG, VAL) \
4577 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4578
4579 if (bfd_link_executable (info))
4580 {
4581 if (!add_dynamic_entry (DT_DEBUG, 0))
4582 return FALSE;
4583 }
4584
4585 if (elf_hash_table (info)->splt->size != 0)
4586 {
4587 if (!add_dynamic_entry (DT_PLTGOT, 0)
4588 || !add_dynamic_entry (DT_PLTRELSZ, 0)
4589 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
4590 || !add_dynamic_entry (DT_JMPREL, 0))
4591 return FALSE;
4592 }
4593
4594 if (htab->tls_desc_trampoline && plt)
4595 {
4596 if (htab->dt_tlsdesc_plt
4597 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
4598 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
4599 return FALSE;
4600 }
4601
4602 if (relocs)
4603 {
4604 if (!add_dynamic_entry (DT_RELA, 0)
4605 || !add_dynamic_entry (DT_RELASZ, 0)
4606 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
4607 return FALSE;
4608
4609 /* If any dynamic relocs apply to a read-only section,
4610 then we need a DT_TEXTREL entry. */
4611 if ((info->flags & DF_TEXTREL) == 0)
4612 elf_link_hash_traverse (&htab->root, maybe_set_textrel,
4613 (void *) info);
4614
4615 if ((info->flags & DF_TEXTREL) != 0)
4616 {
4617 if (!add_dynamic_entry (DT_TEXTREL, 0))
4618 return FALSE;
4619 }
4620 }
4621 }
4622 #undef add_dynamic_entry
4623
4624 return TRUE;
4625 }
4626
4627 static bfd_reloc_status_type
4628 nds32_relocate_contents (reloc_howto_type *howto, bfd *input_bfd,
4629 bfd_vma relocation, bfd_byte *location)
4630 {
4631 int size;
4632 bfd_vma x = 0;
4633 bfd_reloc_status_type flag;
4634 unsigned int rightshift = howto->rightshift;
4635 unsigned int bitpos = howto->bitpos;
4636
4637 /* If the size is negative, negate RELOCATION. This isn't very
4638 general. */
4639 if (howto->size < 0)
4640 relocation = -relocation;
4641
4642 /* Get the value we are going to relocate. */
4643 size = bfd_get_reloc_size (howto);
4644 switch (size)
4645 {
4646 default:
4647 abort ();
4648 break;
4649 case 0:
4650 return bfd_reloc_ok;
4651 case 2:
4652 x = bfd_getb16 (location);
4653 break;
4654 case 4:
4655 x = bfd_getb32 (location);
4656 break;
4657 }
4658
4659 /* Check for overflow. FIXME: We may drop bits during the addition
4660 which we don't check for. We must either check at every single
4661 operation, which would be tedious, or we must do the computations
4662 in a type larger than bfd_vma, which would be inefficient. */
4663 flag = bfd_reloc_ok;
4664 if (howto->complain_on_overflow != complain_overflow_dont)
4665 {
4666 bfd_vma addrmask, fieldmask, signmask, ss;
4667 bfd_vma a, b, sum;
4668
4669 /* Get the values to be added together. For signed and unsigned
4670 relocations, we assume that all values should be truncated to
4671 the size of an address. For bitfields, all the bits matter.
4672 See also bfd_check_overflow. */
4673 fieldmask = N_ONES (howto->bitsize);
4674 signmask = ~fieldmask;
4675 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
4676 a = (relocation & addrmask) >> rightshift;
4677 b = (x & howto->src_mask & addrmask) >> bitpos;
4678
4679 switch (howto->complain_on_overflow)
4680 {
4681 case complain_overflow_signed:
4682 /* If any sign bits are set, all sign bits must be set.
4683 That is, A must be a valid negative address after
4684 shifting. */
4685 signmask = ~(fieldmask >> 1);
4686 /* Fall through. */
4687
4688 case complain_overflow_bitfield:
4689 /* Much like the signed check, but for a field one bit
4690 wider. We allow a bitfield to represent numbers in the
4691 range -2**n to 2**n-1, where n is the number of bits in the
4692 field. Note that when bfd_vma is 32 bits, a 32-bit reloc
4693 can't overflow, which is exactly what we want. */
4694 ss = a & signmask;
4695 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
4696 flag = bfd_reloc_overflow;
4697
4698 /* We only need this next bit of code if the sign bit of B
4699 is below the sign bit of A. This would only happen if
4700 SRC_MASK had fewer bits than BITSIZE. Note that if
4701 SRC_MASK has more bits than BITSIZE, we can get into
4702 trouble; we would need to verify that B is in range, as
4703 we do for A above. */
4704 ss = ((~howto->src_mask) >> 1) & howto->src_mask;
4705 ss >>= bitpos;
4706
4707 /* Set all the bits above the sign bit. */
4708 b = (b ^ ss) - ss;
4709
4710 /* Now we can do the addition. */
4711 sum = a + b;
4712
4713 /* See if the result has the correct sign. Bits above the
4714 sign bit are junk now; ignore them. If the sum is
4715 positive, make sure we did not have all negative inputs;
4716 if the sum is negative, make sure we did not have all
4717 positive inputs. The test below looks only at the sign
4718 bits, and it really just
4719 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
4720
4721 We mask with addrmask here to explicitly allow an address
4722 wrap-around. The Linux kernel relies on it, and it is
4723 the only way to write assembler code which can run when
4724 loaded at a location 0x80000000 away from the location at
4725 which it is linked. */
4726 if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
4727 flag = bfd_reloc_overflow;
4728
4729 break;
4730
4731 case complain_overflow_unsigned:
4732 /* Checking for an unsigned overflow is relatively easy:
4733 trim the addresses and add, and trim the result as well.
4734 Overflow is normally indicated when the result does not
4735 fit in the field. However, we also need to consider the
4736 case when, e.g., fieldmask is 0x7fffffff or smaller, an
4737 input is 0x80000000, and bfd_vma is only 32 bits; then we
4738 will get sum == 0, but there is an overflow, since the
4739 inputs did not fit in the field. Instead of doing a
4740 separate test, we can check for this by or-ing in the
4741 operands when testing for the sum overflowing its final
4742 field. */
4743 sum = (a + b) & addrmask;
4744 if ((a | b | sum) & signmask)
4745 flag = bfd_reloc_overflow;
4746 break;
4747
4748 default:
4749 abort ();
4750 }
4751 }
4752
4753 /* Put RELOCATION in the right bits. */
4754 relocation >>= (bfd_vma) rightshift;
4755 relocation <<= (bfd_vma) bitpos;
4756
4757 /* Add RELOCATION to the right bits of X. */
4758 /* FIXME : 090616
4759 Because the relaxation may generate duplicate relocation at one address,
4760 an addition to immediate in the instruction may cause the relocation added
4761 several times.
4762 This bug should be fixed in assembler, but a check is also needed here. */
4763 if (howto->partial_inplace)
4764 x = ((x & ~howto->dst_mask)
4765 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
4766 else
4767 x = ((x & ~howto->dst_mask) | ((relocation) & howto->dst_mask));
4768
4769
4770 /* Put the relocated value back in the object file. */
4771 switch (size)
4772 {
4773 default:
4774 case 0:
4775 case 1:
4776 case 8:
4777 abort ();
4778 break;
4779 case 2:
4780 bfd_putb16 (x, location);
4781 break;
4782 case 4:
4783 bfd_putb32 (x, location);
4784 break;
4785 }
4786
4787 return flag;
4788 }
4789
4790 static bfd_reloc_status_type
4791 nds32_elf_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd,
4792 asection *input_section, bfd_byte *contents,
4793 bfd_vma address, bfd_vma value, bfd_vma addend)
4794 {
4795 bfd_vma relocation;
4796
4797 /* Sanity check the address. */
4798 if (address > bfd_get_section_limit (input_bfd, input_section))
4799 return bfd_reloc_outofrange;
4800
4801 /* This function assumes that we are dealing with a basic relocation
4802 against a symbol. We want to compute the value of the symbol to
4803 relocate to. This is just VALUE, the value of the symbol, plus
4804 ADDEND, any addend associated with the reloc. */
4805 relocation = value + addend;
4806
4807 /* If the relocation is PC relative, we want to set RELOCATION to
4808 the distance between the symbol (currently in RELOCATION) and the
4809 location we are relocating. If pcrel_offset is FALSE we do not
4810 need to subtract out the offset of the location within the
4811 section (which is just ADDRESS). */
4812 if (howto->pc_relative)
4813 {
4814 relocation -= (input_section->output_section->vma
4815 + input_section->output_offset);
4816 if (howto->pcrel_offset)
4817 relocation -= address;
4818 }
4819
4820 return nds32_relocate_contents (howto, input_bfd, relocation,
4821 contents + address);
4822 }
4823
4824 static bfd_boolean
4825 nds32_elf_output_symbol_hook (struct bfd_link_info *info,
4826 const char *name,
4827 Elf_Internal_Sym *elfsym ATTRIBUTE_UNUSED,
4828 asection *input_sec,
4829 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4830 {
4831 const char *source;
4832 FILE *sym_ld_script = NULL;
4833 struct elf_nds32_link_hash_table *table;
4834
4835 table = nds32_elf_hash_table (info);
4836 sym_ld_script = table->sym_ld_script;
4837 if (!sym_ld_script)
4838 return TRUE;
4839
4840 if (!h || !name || *name == '\0')
4841 return TRUE;
4842
4843 if (input_sec->flags & SEC_EXCLUDE)
4844 return TRUE;
4845
4846 if (!check_start_export_sym)
4847 {
4848 fprintf (sym_ld_script, "SECTIONS\n{\n");
4849 check_start_export_sym = 1;
4850 }
4851
4852 if (h->root.type == bfd_link_hash_defined
4853 || h->root.type == bfd_link_hash_defweak)
4854 {
4855 if (!h->root.u.def.section->output_section)
4856 return TRUE;
4857
4858 if (bfd_is_const_section (input_sec))
4859 source = input_sec->name;
4860 else
4861 source = input_sec->owner->filename;
4862
4863 fprintf (sym_ld_script, "\t%s = 0x%08lx;\t /* %s */\n",
4864 h->root.root.string,
4865 (long) (h->root.u.def.value
4866 + h->root.u.def.section->output_section->vma
4867 + h->root.u.def.section->output_offset), source);
4868 }
4869
4870 return TRUE;
4871 }
4872
4873 /* Relocate an NDS32/D ELF section.
4874 There is some attempt to make this function usable for many architectures,
4875 both for RELA and REL type relocs, if only to serve as a learning tool.
4876
4877 The RELOCATE_SECTION function is called by the new ELF backend linker
4878 to handle the relocations for a section.
4879
4880 The relocs are always passed as Rela structures; if the section
4881 actually uses Rel structures, the r_addend field will always be
4882 zero.
4883
4884 This function is responsible for adjust the section contents as
4885 necessary, and (if using Rela relocs and generating a
4886 relocatable output file) adjusting the reloc addend as
4887 necessary.
4888
4889 This function does not have to worry about setting the reloc
4890 address or the reloc symbol index.
4891
4892 LOCAL_SYMS is a pointer to the swapped in local symbols.
4893
4894 LOCAL_SECTIONS is an array giving the section in the input file
4895 corresponding to the st_shndx field of each local symbol.
4896
4897 The global hash table entry for the global symbols can be found
4898 via elf_sym_hashes (input_bfd).
4899
4900 When generating relocatable output, this function must handle
4901 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
4902 going to be the section symbol corresponding to the output
4903 section, which means that the addend must be adjusted
4904 accordingly. */
4905
4906 /* Return the base VMA address which should be subtracted from real addresses
4907 when resolving @dtpoff relocation.
4908 This is PT_TLS segment p_vaddr. */
4909
4910 /* Return the relocation value for @tpoff relocation
4911 if STT_TLS virtual address is ADDRESS. */
4912
4913 /* Return the relocation value for @gottpoff relocation
4914 if STT_TLS virtual address is ADDRESS. */
4915
4916 static bfd_vma
4917 gottpoff (struct bfd_link_info *info, bfd_vma address)
4918 {
4919 bfd_vma tp_base;
4920 bfd_vma tp_offset;
4921
4922 /* If tls_sec is NULL, we should have signalled an error already. */
4923 if (elf_hash_table (info)->tls_sec == NULL)
4924 return 0;
4925
4926 tp_base = elf_hash_table (info)->tls_sec->vma;
4927 tp_offset = address - tp_base;
4928
4929 return tp_offset;
4930 }
4931
4932 static bfd_boolean
4933 patch_tls_desc_to_ie (bfd_byte *contents, Elf_Internal_Rela *rel, bfd *ibfd)
4934 {
4935 /* TLS_GD/TLS_LD model #1
4936 46 00 00 00 sethi $r0,#0x0
4937 58 00 00 00 ori $r0,$r0,#0x0
4938 40 00 74 00 add $r0,$r0,$gp
4939 04 10 00 00 lwi $r1,[$r0+#0x0]
4940 4b e0 04 01 jral $lp,$r1 */
4941
4942 /* TLS_GD/TLS_LD model #2
4943 46 00 00 00 sethi $r0,#0x0
4944 58 00 00 00 ori $r0,$r0,#0x0
4945 38 10 74 02 lw $r1,[$r0+($gp<<#0x0)]
4946 40 00 74 00 add $r0,$r0,$gp
4947 4b e0 04 01 jral $lp,$r1 */
4948
4949 /* TLS_IE model (non-PIC)
4950 46 00 00 00 sethi $r0,#0x0
4951 04 00 00 00 lwi $r0,[$r0+#0x0]
4952 38 00 64 02 lw $r0,[$r0+($r25<<#0x0)] */
4953
4954 /* TLS_IE model (PIC)
4955 46 00 00 00 sethi $r0,#0x0
4956 58 00 00 00 ori $r0,$r0,#0x0
4957 38 00 74 02 lw $r0,[$r0+($gp<<#0x0)]
4958 38 00 64 02 lw $r0,[$r0+($r25<<#0x0)] */
4959
4960 /* TLS_GD_TO_IE model
4961 46 00 00 00 sethi $r0,#0x0
4962 58 00 00 00 ori $r0,$r0,#0x0
4963 40 00 74 00 add $r0,$rM,$gp
4964 04 00 00 01 lwi $r0,[$r0+#0x4]
4965 40 00 64 00 add $r0,$r0,$r25 */
4966
4967 bfd_boolean rz = FALSE;
4968
4969 typedef struct
4970 {
4971 uint32_t opcode;
4972 uint32_t mask;
4973 } pat_t;
4974
4975 uint32_t patch[3] =
4976 {
4977 0x40007400, /* add $r0,$rM,$gp */
4978 0x04000001, /* lwi $r0,[$r0+#0x4] */
4979 0x40006400, /* add $r0,$r0,$r25 */
4980 };
4981
4982 pat_t mode0[3] =
4983 {
4984 { 0x40000000, 0xfe0003ff },
4985 { 0x04000000, 0xfe000000 },
4986 { 0x4be00001, 0xffff83ff },
4987 };
4988
4989 pat_t mode1[3] =
4990 {
4991 { 0x38007402, 0xfe007fff },
4992 { 0x40007400, 0xfe007fff },
4993 { 0x4be00001, 0xffff83ff },
4994 };
4995
4996 unsigned char *p = contents + rel->r_offset;
4997
4998 uint32_t insn;
4999 uint32_t regidx = 0;
5000 insn = bfd_getb32 (p);
5001 if (INSN_SETHI == (0xfe0fffffu & insn))
5002 {
5003 regidx = 0x1f & (insn >> 20);
5004 p += 4;
5005 }
5006
5007 insn = bfd_getb32 (p);
5008 if (INSN_ORI == (0xfe007fffu & insn))
5009 {
5010 regidx = 0x1f & (insn >> 20);
5011 p += 4;
5012 }
5013
5014 if (patch[2] == bfd_getb32 (p + 8)) /* Character instruction. */
5015 {
5016 /* already patched? */
5017 if ((patch[0] == (0xfff07fffu & bfd_getb32 (p + 0))) &&
5018 (patch[1] == bfd_getb32 (p + 4)))
5019 rz = TRUE;
5020 }
5021 else if (mode0[0].opcode == (mode0[0].mask & bfd_getb32 (p + 0)))
5022 {
5023 if ((mode0[1].opcode == (mode0[1].mask & bfd_getb32 (p + 4))) &&
5024 (mode0[2].opcode == (mode0[2].mask & bfd_getb32 (p + 8))))
5025 {
5026 bfd_putb32 (patch[0] | (regidx << 15), p + 0);
5027 bfd_putb32 (patch[1], p + 4);
5028 bfd_putb32 (patch[2], p + 8);
5029 rz = TRUE;
5030 }
5031 }
5032 else if (mode1[0].opcode == (mode1[0].mask & bfd_getb32 (p + 0)))
5033 {
5034 if ((mode1[1].opcode == (mode1[1].mask & bfd_getb32 (p + 4))) &&
5035 (mode1[2].opcode == (mode1[2].mask & bfd_getb32 (p + 8))))
5036 {
5037 bfd_putb32 (patch[0] | (regidx << 15), p + 0);
5038 bfd_putb32 (patch[1], p + 4);
5039 bfd_putb32 (patch[2], p + 8);
5040 rz = TRUE;
5041 }
5042 }
5043
5044 if (!rz)
5045 {
5046 printf ("%s: %s @ 0x%08x\n", __func__, ibfd->filename,
5047 (int) rel->r_offset);
5048 BFD_ASSERT(0); /* Unsupported pattern. */
5049 }
5050
5051 return rz;
5052 }
5053
5054 static enum elf_nds32_tls_type
5055 get_tls_type (enum elf_nds32_reloc_type r_type, struct elf_link_hash_entry *h);
5056
5057 static unsigned int
5058 ones32 (register unsigned int x)
5059 {
5060 /* 32-bit recursive reduction using SWAR...
5061 but first step is mapping 2-bit values
5062 into sum of 2 1-bit values in sneaky way. */
5063 x -= ((x >> 1) & 0x55555555);
5064 x = (((x >> 2) & 0x33333333) + (x & 0x33333333));
5065 x = (((x >> 4) + x) & 0x0f0f0f0f);
5066 x += (x >> 8);
5067 x += (x >> 16);
5068 return (x & 0x0000003f);
5069 }
5070
5071 #if !HAVE_FLS
5072 static unsigned int
5073 fls (register unsigned int x)
5074 {
5075 return ffs (x & (-x));
5076 }
5077 #endif /* !HAVE_FLS */
5078
5079 #define nds32_elf_local_tlsdesc_gotent(bfd) \
5080 (elf_nds32_tdata (bfd)->local_tlsdesc_gotent)
5081
5082 static bfd_boolean
5083 nds32_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
5084 struct bfd_link_info * info,
5085 bfd * input_bfd,
5086 asection * input_section,
5087 bfd_byte * contents,
5088 Elf_Internal_Rela * relocs,
5089 Elf_Internal_Sym * local_syms,
5090 asection ** local_sections)
5091 {
5092 Elf_Internal_Shdr *symtab_hdr;
5093 struct elf_link_hash_entry **sym_hashes;
5094 Elf_Internal_Rela *rel, *relend;
5095 bfd_boolean ret = TRUE; /* Assume success. */
5096 int align = 0;
5097 bfd_reloc_status_type r;
5098 const char *errmsg = NULL;
5099 bfd_vma gp;
5100 struct elf_link_hash_table *ehtab;
5101 struct elf_nds32_link_hash_table *htab;
5102 bfd *dynobj;
5103 bfd_vma *local_got_offsets;
5104 asection *sgot, *splt, *sreloc;
5105 bfd_vma high_address;
5106 struct elf_nds32_link_hash_table *table;
5107 int eliminate_gc_relocs;
5108 bfd_vma fpbase_addr;
5109
5110 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5111 sym_hashes = elf_sym_hashes (input_bfd);
5112 ehtab = elf_hash_table (info);
5113 htab = nds32_elf_hash_table (info);
5114 high_address = bfd_get_section_limit (input_bfd, input_section);
5115
5116 dynobj = htab->root.dynobj;
5117 local_got_offsets = elf_local_got_offsets (input_bfd);
5118
5119 sgot = ehtab->sgot;
5120 splt = ehtab->splt;
5121 sreloc = NULL;
5122
5123 rel = relocs;
5124 relend = relocs + input_section->reloc_count;
5125
5126 table = nds32_elf_hash_table (info);
5127 eliminate_gc_relocs = table->eliminate_gc_relocs;
5128
5129 /* By this time, we can adjust the value of _SDA_BASE_. */
5130 /* Explain _SDA_BASE_ */
5131 if ((!bfd_link_relocatable (info)))
5132 {
5133 is_SDA_BASE_set = 1;
5134 r = nds32_elf_final_sda_base (output_bfd, info, &gp, TRUE);
5135 if (r != bfd_reloc_ok)
5136 return FALSE;
5137 }
5138
5139 /* Do TLS model conversion once at first. */
5140 nds32_elf_unify_tls_model (input_bfd, input_section, contents, info);
5141
5142 /* Use gp as fp to prevent truncated fit. Because in relaxation time
5143 the fp value is set as gp, and it has be reverted for instruction
5144 setting fp. */
5145 fpbase_addr = elf_gp (output_bfd);
5146
5147 /* Deal with (dynamic) relocations. */
5148 for (rel = relocs; rel < relend; rel++)
5149 {
5150 enum elf_nds32_reloc_type r_type;
5151 reloc_howto_type *howto = NULL;
5152 unsigned long r_symndx;
5153 struct elf_link_hash_entry *h = NULL;
5154 Elf_Internal_Sym *sym = NULL;
5155 asection *sec;
5156 bfd_vma relocation;
5157 bfd_vma relocation_sym = 0xdeadbeef;
5158 Elf_Internal_Rela *lorel;
5159 bfd_vma off;
5160
5161 /* We can't modify r_addend here as elf_link_input_bfd has an assert to
5162 ensure it's zero (we use REL relocs, not RELA). Therefore this
5163 should be assigning zero to `addend', but for clarity we use
5164 `r_addend'. */
5165
5166 bfd_vma addend = rel->r_addend;
5167 bfd_vma offset = rel->r_offset;
5168
5169 r_type = ELF32_R_TYPE (rel->r_info);
5170 if (r_type >= R_NDS32_max)
5171 {
5172 /* xgettext:c-format */
5173 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
5174 input_bfd, r_type);
5175 bfd_set_error (bfd_error_bad_value);
5176 ret = FALSE;
5177 continue;
5178 }
5179
5180 if (r_type == R_NDS32_GNU_VTENTRY
5181 || r_type == R_NDS32_GNU_VTINHERIT
5182 || r_type == R_NDS32_NONE
5183 || r_type == R_NDS32_RELA_GNU_VTENTRY
5184 || r_type == R_NDS32_RELA_GNU_VTINHERIT
5185 || (r_type >= R_NDS32_INSN16 && r_type <= R_NDS32_25_FIXED_RELA)
5186 || r_type == R_NDS32_DATA
5187 || r_type == R_NDS32_TRAN)
5188 continue;
5189
5190 /* If we enter the fp-as-gp region. Resolve the address
5191 of best fp-base. */
5192 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_BEGIN
5193 && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
5194 {
5195 int dist;
5196
5197 /* Distance to relocation of best fp-base is encoded in R_SYM. */
5198 dist = rel->r_addend >> 16;
5199 fpbase_addr = calculate_memory_address (input_bfd, rel + dist,
5200 local_syms, symtab_hdr);
5201 }
5202 else if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_END
5203 && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
5204 {
5205 fpbase_addr = elf_gp (output_bfd);
5206 }
5207
5208 /* Skip the relocations used for relaxation. */
5209 /* We have to update LONGCALL and LONGJUMP
5210 relocations when generating the relocatable files. */
5211 if (!bfd_link_relocatable (info)
5212 && (r_type >= R_NDS32_RELAX_ENTRY
5213 || (r_type >= R_NDS32_LONGCALL4
5214 && r_type <= R_NDS32_LONGJUMP7)))
5215 continue;
5216
5217 howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
5218 r_symndx = ELF32_R_SYM (rel->r_info);
5219
5220 /* This is a final link. */
5221 sym = NULL;
5222 sec = NULL;
5223 h = NULL;
5224
5225 if (r_symndx < symtab_hdr->sh_info)
5226 {
5227 /* Local symbol. */
5228 sym = local_syms + r_symndx;
5229 sec = local_sections[r_symndx];
5230
5231 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
5232 addend = rel->r_addend;
5233
5234 /* keep symbol location for static TLS_IE GOT entry */
5235 relocation_sym = relocation;
5236 if (bfd_link_relocatable (info))
5237 {
5238 /* This is a relocatable link. We don't have to change
5239 anything, unless the reloc is against a section symbol,
5240 in which case we have to adjust according to where the
5241 section symbol winds up in the output section. */
5242 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5243 rel->r_addend += sec->output_offset + sym->st_value;
5244
5245 continue;
5246 }
5247 }
5248 else
5249 {
5250 /* External symbol. */
5251 if (bfd_link_relocatable (info))
5252 continue;
5253 bfd_boolean warned, ignored, unresolved_reloc;
5254 int symndx = r_symndx - symtab_hdr->sh_info;
5255
5256 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
5257 r_symndx, symtab_hdr, sym_hashes, h, sec,
5258 relocation, unresolved_reloc, warned,
5259 ignored);
5260
5261 /* keep symbol location for static TLS_IE GOT entry */
5262 relocation_sym = relocation;
5263
5264 /* la $fp, _FP_BASE_ is per-function (region).
5265 Handle it specially. */
5266 switch ((int) r_type)
5267 {
5268 case R_NDS32_HI20_RELA:
5269 case R_NDS32_LO12S0_RELA:
5270 if (strcmp (elf_sym_hashes (input_bfd)[symndx]->root.root.string,
5271 FP_BASE_NAME) == 0)
5272 {
5273 if (!bfd_link_pie (info))
5274 {
5275 _bfd_error_handler
5276 ("%pB: warning: _FP_BASE_ setting insns relaxation failed.",
5277 input_bfd);
5278 }
5279 relocation = fpbase_addr;
5280 }
5281 break;
5282 case R_NDS32_SDA19S0_RELA:
5283 case R_NDS32_SDA15S0_RELA:
5284 case R_NDS32_20_RELA:
5285 if (strcmp (elf_sym_hashes (input_bfd)[symndx]->root.root.string,
5286 FP_BASE_NAME) == 0)
5287 {
5288 relocation = fpbase_addr;
5289 break;
5290 }
5291 }
5292 }
5293
5294 /* Sanity check the address. */
5295 if (offset > high_address)
5296 {
5297 r = bfd_reloc_outofrange;
5298 goto check_reloc;
5299 }
5300
5301 if (r_type >= R_NDS32_RELAX_ENTRY)
5302 continue;
5303
5304 switch ((int) r_type)
5305 {
5306 case R_NDS32_GOTOFF:
5307 /* Relocation is relative to the start of the global offset
5308 table (for ld24 rx, #uimm24), e.g. access at label+addend
5309
5310 ld24 rx. #label@GOTOFF + addend
5311 sub rx, r12. */
5312 case R_NDS32_GOTOFF_HI20:
5313 case R_NDS32_GOTOFF_LO12:
5314 case R_NDS32_GOTOFF_LO15:
5315 case R_NDS32_GOTOFF_LO19:
5316 BFD_ASSERT (sgot != NULL);
5317
5318 relocation -= elf_gp (output_bfd);
5319 break;
5320
5321 case R_NDS32_9_PLTREL:
5322 case R_NDS32_25_PLTREL:
5323 /* Relocation is to the entry for this symbol in the
5324 procedure linkage table. */
5325
5326 /* The native assembler will generate a 25_PLTREL reloc
5327 for a local symbol if you assemble a call from one
5328 section to another when using -K pic. */
5329 if (h == NULL)
5330 break;
5331
5332 if (h->forced_local)
5333 break;
5334
5335 /* We didn't make a PLT entry for this symbol. This
5336 happens when statically linking PIC code, or when
5337 using -Bsymbolic. */
5338 if (h->plt.offset == (bfd_vma) - 1)
5339 break;
5340
5341 relocation = (splt->output_section->vma
5342 + splt->output_offset + h->plt.offset);
5343 break;
5344
5345 case R_NDS32_PLT_GOTREL_HI20:
5346 case R_NDS32_PLT_GOTREL_LO12:
5347 case R_NDS32_PLT_GOTREL_LO15:
5348 case R_NDS32_PLT_GOTREL_LO19:
5349 case R_NDS32_PLT_GOTREL_LO20:
5350 if (h == NULL
5351 || h->forced_local
5352 || h->plt.offset == (bfd_vma) -1
5353 || (bfd_link_pie (info) && h->def_regular))
5354 {
5355 /* Maybe we should find better checking to optimize
5356 PIE PLT relocations. */
5357 /* We didn't make a PLT entry for this symbol. This
5358 happens when statically linking PIC code, or when
5359 using -Bsymbolic. */
5360 if (h)
5361 h->plt.offset = (bfd_vma) -1; /* Cancel PLT trampoline. */
5362 relocation -= elf_gp (output_bfd);
5363 break;
5364 }
5365
5366 relocation = (splt->output_section->vma
5367 + splt->output_offset + h->plt.offset);
5368
5369 relocation -= elf_gp (output_bfd);
5370 break;
5371
5372 case R_NDS32_PLTREL_HI20:
5373 case R_NDS32_PLTREL_LO12:
5374
5375 /* Relocation is to the entry for this symbol in the
5376 procedure linkage table. */
5377
5378 /* The native assembler will generate a 25_PLTREL reloc
5379 for a local symbol if you assemble a call from one
5380 section to another when using -K pic. */
5381 if (h == NULL)
5382 break;
5383
5384 if (h->forced_local)
5385 break;
5386
5387 if (h->plt.offset == (bfd_vma) - 1)
5388 /* We didn't make a PLT entry for this symbol. This
5389 happens when statically linking PIC code, or when
5390 using -Bsymbolic. */
5391 break;
5392
5393 if (splt == NULL)
5394 break;
5395
5396 relocation = (splt->output_section->vma
5397 + splt->output_offset
5398 + h->plt.offset + 4)
5399 - (input_section->output_section->vma
5400 + input_section->output_offset
5401 + rel->r_offset);
5402
5403 break;
5404
5405 case R_NDS32_GOTPC20:
5406 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
5407 ld24 rx,#_GLOBAL_OFFSET_TABLE_ */
5408 relocation = elf_gp (output_bfd);
5409 break;
5410
5411 case R_NDS32_GOTPC_HI20:
5412 case R_NDS32_GOTPC_LO12:
5413 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
5414 bl .+4
5415 seth rx,#high(_GLOBAL_OFFSET_TABLE_)
5416 or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
5417 or
5418 bl .+4
5419 seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
5420 add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4) */
5421 relocation = elf_gp (output_bfd);
5422 relocation -= (input_section->output_section->vma
5423 + input_section->output_offset + rel->r_offset);
5424 break;
5425
5426 case R_NDS32_GOT20:
5427 /* Fall through. */
5428 case R_NDS32_GOT_HI20:
5429 case R_NDS32_GOT_LO12:
5430 case R_NDS32_GOT_LO15:
5431 case R_NDS32_GOT_LO19:
5432 /* Relocation is to the entry for this symbol in the global
5433 offset table. */
5434 BFD_ASSERT (sgot != NULL);
5435
5436 if (h != NULL)
5437 {
5438 /* External symbol */
5439 bfd_boolean dyn;
5440
5441 off = h->got.offset;
5442 BFD_ASSERT (off != (bfd_vma) - 1);
5443 dyn = htab->root.dynamic_sections_created;
5444 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
5445 bfd_link_pic (info),
5446 h)
5447 || (bfd_link_pic (info)
5448 && (info->symbolic
5449 || h->dynindx == -1
5450 || h->forced_local) && h->def_regular))
5451 {
5452 /* This is actually a static link, or it is a
5453 -Bsymbolic link and the symbol is defined
5454 locally, or the symbol was forced to be local
5455 because of a version file. We must initialize
5456 this entry in the global offset table. Since the
5457 offset must always be a multiple of 4, we use the
5458 least significant bit to record whether we have
5459 initialized it already.
5460
5461 When doing a dynamic link, we create a .rela.got
5462 relocation entry to initialize the value. This
5463 is done in the finish_dynamic_symbol routine. */
5464 if ((off & 1) != 0) /* clear LSB */
5465 off &= ~1;
5466 else
5467 {
5468 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5469 h->got.offset |= 1;
5470 }
5471 }
5472 relocation = sgot->output_section->vma + sgot->output_offset + off
5473 - elf_gp (output_bfd);
5474 }
5475 else
5476 {
5477 /* Local symbol */
5478 bfd_byte *loc;
5479
5480 BFD_ASSERT (local_got_offsets != NULL
5481 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5482
5483 off = local_got_offsets[r_symndx];
5484
5485 /* The offset must always be a multiple of 4. We use
5486 the least significant bit to record whether we have
5487 already processed this entry. */
5488 if ((off & 1) != 0) /* clear LSB */
5489 off &= ~1;
5490 else
5491 {
5492 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5493
5494 if (bfd_link_pic (info))
5495 {
5496 asection *srelgot;
5497 Elf_Internal_Rela outrel;
5498
5499 /* We need to generate a R_NDS32_RELATIVE reloc
5500 for the dynamic linker. */
5501 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5502 BFD_ASSERT (srelgot != NULL);
5503
5504 outrel.r_offset = (elf_gp (output_bfd)
5505 + sgot->output_offset + off);
5506 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5507 outrel.r_addend = relocation;
5508 loc = srelgot->contents;
5509 loc +=
5510 srelgot->reloc_count * sizeof (Elf32_External_Rela);
5511 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5512 ++srelgot->reloc_count;
5513 }
5514 local_got_offsets[r_symndx] |= 1;
5515 }
5516 relocation = sgot->output_section->vma + sgot->output_offset + off
5517 - elf_gp (output_bfd);
5518 }
5519
5520 break;
5521
5522 case R_NDS32_16_RELA:
5523 case R_NDS32_20_RELA:
5524 case R_NDS32_5_RELA:
5525 case R_NDS32_32_RELA:
5526 case R_NDS32_9_PCREL_RELA:
5527 case R_NDS32_WORD_9_PCREL_RELA:
5528 case R_NDS32_10_UPCREL_RELA:
5529 case R_NDS32_15_PCREL_RELA:
5530 case R_NDS32_17_PCREL_RELA:
5531 case R_NDS32_25_PCREL_RELA:
5532 case R_NDS32_HI20_RELA:
5533 case R_NDS32_LO12S3_RELA:
5534 case R_NDS32_LO12S2_RELA:
5535 case R_NDS32_LO12S2_DP_RELA:
5536 case R_NDS32_LO12S2_SP_RELA:
5537 case R_NDS32_LO12S1_RELA:
5538 case R_NDS32_LO12S0_RELA:
5539 case R_NDS32_LO12S0_ORI_RELA:
5540 if (bfd_link_pic (info) && r_symndx != 0
5541 && (input_section->flags & SEC_ALLOC) != 0
5542 && (eliminate_gc_relocs == 0
5543 || (sec && (sec->flags & SEC_EXCLUDE) == 0))
5544 && ((r_type != R_NDS32_9_PCREL_RELA
5545 && r_type != R_NDS32_WORD_9_PCREL_RELA
5546 && r_type != R_NDS32_10_UPCREL_RELA
5547 && r_type != R_NDS32_15_PCREL_RELA
5548 && r_type != R_NDS32_17_PCREL_RELA
5549 && r_type != R_NDS32_25_PCREL_RELA
5550 && !(r_type == R_NDS32_32_RELA
5551 && strcmp (input_section->name, ".eh_frame") == 0))
5552 || (h != NULL && h->dynindx != -1
5553 && (!info->symbolic || !h->def_regular))))
5554 {
5555 Elf_Internal_Rela outrel;
5556 bfd_boolean skip, relocate;
5557 bfd_byte *loc;
5558
5559 /* When generating a shared object, these relocations
5560 are copied into the output file to be resolved at run
5561 time. */
5562
5563 if (sreloc == NULL)
5564 {
5565 const char *name;
5566
5567 name = bfd_elf_string_from_elf_section
5568 (input_bfd, elf_elfheader (input_bfd)->e_shstrndx,
5569 elf_section_data (input_section)->rela.hdr->sh_name);
5570 if (name == NULL)
5571 return FALSE;
5572
5573 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5574 && strcmp (bfd_get_section_name (input_bfd,
5575 input_section),
5576 name + 5) == 0);
5577
5578 sreloc = bfd_get_section_by_name (dynobj, name);
5579 BFD_ASSERT (sreloc != NULL);
5580 }
5581
5582 skip = FALSE;
5583 relocate = FALSE;
5584
5585 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
5586 info,
5587 input_section,
5588 rel->r_offset);
5589 if (outrel.r_offset == (bfd_vma) - 1)
5590 skip = TRUE;
5591 else if (outrel.r_offset == (bfd_vma) - 2)
5592 skip = TRUE, relocate = TRUE;
5593 outrel.r_offset += (input_section->output_section->vma
5594 + input_section->output_offset);
5595
5596 if (skip)
5597 memset (&outrel, 0, sizeof outrel);
5598 else if (r_type == R_NDS32_17_PCREL_RELA
5599 || r_type == R_NDS32_15_PCREL_RELA
5600 || r_type == R_NDS32_25_PCREL_RELA)
5601 {
5602 BFD_ASSERT (h != NULL && h->dynindx != -1);
5603 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
5604 outrel.r_addend = rel->r_addend;
5605 }
5606 else
5607 {
5608 /* h->dynindx may be -1 if this symbol was marked to
5609 become local. */
5610 if (h == NULL
5611 || ((info->symbolic || h->dynindx == -1)
5612 && h->def_regular)
5613 || (bfd_link_pie (info) && h->def_regular))
5614 {
5615 relocate = TRUE;
5616 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5617 outrel.r_addend = relocation + rel->r_addend;
5618
5619 if (h)
5620 {
5621 h->plt.offset = (bfd_vma) -1; /* cancel PLT trampoline. */
5622
5623 BFD_ASSERT (sgot != NULL);
5624 /* If we did not allocate got entry for the symbol,
5625 we can not fill the nonexistent got entry. */
5626 if (h->got.offset != (bfd_vma) -1
5627 && (h->got.offset & 1) == 0)
5628 {
5629 bfd_put_32 (output_bfd, outrel.r_addend,
5630 sgot->contents + h->got.offset);
5631 }
5632 }
5633 }
5634 else
5635 {
5636 if (h->dynindx == -1)
5637 {
5638 _bfd_error_handler
5639 (_("%pB: relocation %s against `%s' can not be used when "
5640 "making a shared object; recompile with -fPIC"),
5641 input_bfd, nds32_elf_howto_table[r_type].name, h->root.root.string);
5642 bfd_set_error (bfd_error_bad_value);
5643 return FALSE;
5644 }
5645
5646 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
5647 outrel.r_addend = rel->r_addend;
5648 }
5649 }
5650
5651 loc = sreloc->contents;
5652 loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
5653 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5654 ++sreloc->reloc_count;
5655
5656 /* If this reloc is against an external symbol, we do
5657 not want to fiddle with the addend. Otherwise, we
5658 need to include the symbol value so that it becomes
5659 an addend for the dynamic reloc. */
5660 if (!relocate)
5661 continue;
5662 }
5663 break;
5664
5665 case R_NDS32_25_ABS_RELA:
5666 if (bfd_link_pic (info))
5667 {
5668 _bfd_error_handler
5669 (_("%pB: warning: %s unsupported in shared mode"),
5670 input_bfd, "R_NDS32_25_ABS_RELA");
5671 return FALSE;
5672 }
5673 break;
5674
5675 case R_NDS32_9_PCREL:
5676 r = nds32_elf_do_9_pcrel_reloc (input_bfd, howto, input_section,
5677 contents, offset,
5678 sec, relocation, addend);
5679 goto check_reloc;
5680
5681 case R_NDS32_HI20:
5682 /* We allow an arbitrary number of HI20 relocs before the
5683 LO12 reloc. This permits gcc to emit the HI and LO relocs
5684 itself. */
5685 for (lorel = rel + 1;
5686 (lorel < relend
5687 && ELF32_R_TYPE (lorel->r_info) == R_NDS32_HI20); lorel++)
5688 continue;
5689 if (lorel < relend
5690 && (ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S3
5691 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S2
5692 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S1
5693 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S0))
5694 {
5695 nds32_elf_relocate_hi20 (input_bfd, r_type, rel, lorel,
5696 contents, relocation + addend);
5697 r = bfd_reloc_ok;
5698 }
5699 else
5700 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5701 contents, offset, relocation,
5702 addend);
5703 goto check_reloc;
5704
5705 case R_NDS32_GOT17S2_RELA:
5706 case R_NDS32_GOT15S2_RELA:
5707 BFD_ASSERT (sgot != NULL);
5708
5709 if (h != NULL)
5710 {
5711 bfd_boolean dyn;
5712
5713 off = h->got.offset;
5714 BFD_ASSERT (off != (bfd_vma) - 1);
5715
5716 dyn = htab->root.dynamic_sections_created;
5717 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL
5718 (dyn, bfd_link_pic (info), h)
5719 || (bfd_link_pic (info)
5720 && (info->symbolic
5721 || h->dynindx == -1
5722 || h->forced_local)
5723 && h->def_regular))
5724 {
5725 /* This is actually a static link, or it is a
5726 -Bsymbolic link and the symbol is defined
5727 locally, or the symbol was forced to be local
5728 because of a version file. We must initialize
5729 this entry in the global offset table. Since the
5730 offset must always be a multiple of 4, we use the
5731 least significant bit to record whether we have
5732 initialized it already.
5733
5734 When doing a dynamic link, we create a .rela.got
5735 relocation entry to initialize the value. This
5736 is done in the finish_dynamic_symbol routine. */
5737 if ((off & 1) != 0)
5738 off &= ~1;
5739 else
5740 {
5741 bfd_put_32 (output_bfd, relocation,
5742 sgot->contents + off);
5743 h->got.offset |= 1;
5744 }
5745 }
5746 }
5747 else
5748 {
5749 bfd_byte *loc;
5750
5751 BFD_ASSERT (local_got_offsets != NULL
5752 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5753
5754 off = local_got_offsets[r_symndx];
5755
5756 /* The offset must always be a multiple of 4. We use
5757 the least significant bit to record whether we have
5758 already processed this entry. */
5759 if ((off & 1) != 0)
5760 off &= ~1;
5761 else
5762 {
5763 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5764
5765 if (bfd_link_pic (info))
5766 {
5767 asection *srelgot;
5768 Elf_Internal_Rela outrel;
5769
5770 /* We need to generate a R_NDS32_RELATIVE reloc
5771 for the dynamic linker. */
5772 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5773 BFD_ASSERT (srelgot != NULL);
5774
5775 outrel.r_offset = (elf_gp (output_bfd)
5776 + sgot->output_offset + off);
5777 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5778 outrel.r_addend = relocation;
5779 loc = srelgot->contents;
5780 loc +=
5781 srelgot->reloc_count * sizeof (Elf32_External_Rela);
5782 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5783 ++srelgot->reloc_count;
5784 }
5785 local_got_offsets[r_symndx] |= 1;
5786 }
5787 }
5788 relocation = sgot->output_section->vma + sgot->output_offset + off
5789 - elf_gp (output_bfd);
5790
5791 if (relocation & align)
5792 {
5793 /* Incorrect alignment. */
5794 _bfd_error_handler
5795 (_("%pB: warning: unaligned access to GOT entry"), input_bfd);
5796 ret = FALSE;
5797 r = bfd_reloc_dangerous;
5798 goto check_reloc;
5799 }
5800 break;
5801
5802 case R_NDS32_SDA16S3_RELA:
5803 case R_NDS32_SDA15S3_RELA:
5804 case R_NDS32_SDA15S3:
5805 align = 0x7;
5806 goto handle_sda;
5807
5808 case R_NDS32_SDA17S2_RELA:
5809 case R_NDS32_SDA15S2_RELA:
5810 case R_NDS32_SDA12S2_SP_RELA:
5811 case R_NDS32_SDA12S2_DP_RELA:
5812 case R_NDS32_SDA15S2:
5813 case R_NDS32_SDA_FP7U2_RELA:
5814 align = 0x3;
5815 goto handle_sda;
5816
5817 case R_NDS32_SDA18S1_RELA:
5818 case R_NDS32_SDA15S1_RELA:
5819 case R_NDS32_SDA15S1:
5820 align = 0x1;
5821 goto handle_sda;
5822
5823 case R_NDS32_SDA19S0_RELA:
5824 case R_NDS32_SDA15S0_RELA:
5825 case R_NDS32_SDA15S0:
5826 align = 0x0;
5827 handle_sda:
5828 BFD_ASSERT (sec != NULL);
5829
5830 /* If the symbol is in the abs section, the out_bfd will be null.
5831 This happens when the relocation has a symbol@GOTOFF. */
5832 r = nds32_elf_final_sda_base (output_bfd, info, &gp, FALSE);
5833 if (r != bfd_reloc_ok)
5834 {
5835 _bfd_error_handler
5836 (_("%pB: warning: relocate SDA_BASE failed"), input_bfd);
5837 ret = FALSE;
5838 goto check_reloc;
5839 }
5840
5841 /* At this point `relocation' contains the object's
5842 address. */
5843 if (r_type == R_NDS32_SDA_FP7U2_RELA)
5844 {
5845 relocation -= fpbase_addr;
5846 }
5847 else
5848 relocation -= gp;
5849 /* Now it contains the offset from _SDA_BASE_. */
5850
5851 /* Make sure alignment is correct. */
5852
5853 if (relocation & align)
5854 {
5855 /* Incorrect alignment. */
5856 _bfd_error_handler
5857 /* xgettext:c-format */
5858 (_("%pB(%pA): warning: unaligned small data access"
5859 " of type %d"),
5860 input_bfd, input_section, r_type);
5861 ret = FALSE;
5862 goto check_reloc;
5863 }
5864 break;
5865
5866 case R_NDS32_17IFC_PCREL_RELA:
5867 case R_NDS32_10IFCU_PCREL_RELA:
5868 /* Do nothing. */
5869 break;
5870
5871 case R_NDS32_TLS_LE_HI20:
5872 case R_NDS32_TLS_LE_LO12:
5873 case R_NDS32_TLS_LE_20:
5874 case R_NDS32_TLS_LE_15S0:
5875 case R_NDS32_TLS_LE_15S1:
5876 case R_NDS32_TLS_LE_15S2:
5877 /* We do not have garbage collection for got entries.
5878 Therefore, IE to LE may have one empty entry, and DESC to
5879 LE may have two. */
5880 if (elf_hash_table (info)->tls_sec != NULL)
5881 relocation -= (elf_hash_table (info)->tls_sec->vma + TP_OFFSET);
5882 break;
5883
5884 case R_NDS32_TLS_IE_HI20:
5885 case R_NDS32_TLS_IE_LO12S2:
5886 case R_NDS32_TLS_DESC_HI20:
5887 case R_NDS32_TLS_DESC_LO12:
5888 case R_NDS32_TLS_IE_LO12:
5889 case R_NDS32_TLS_IEGP_HI20:
5890 case R_NDS32_TLS_IEGP_LO12:
5891 case R_NDS32_TLS_IEGP_LO12S2:
5892 {
5893 /* Relocation is to the entry for this symbol in the global
5894 offset table. */
5895 enum elf_nds32_tls_type tls_type, org_tls_type, eff_tls_type;
5896 asection *srelgot;
5897 Elf_Internal_Rela outrel;
5898 bfd_byte *loc;
5899 int indx = 0;
5900
5901 eff_tls_type = org_tls_type = get_tls_type (r_type, h);
5902
5903 BFD_ASSERT (sgot != NULL);
5904 if (h != NULL)
5905 {
5906 bfd_boolean dyn;
5907
5908 off = h->got.offset;
5909 BFD_ASSERT (off != (bfd_vma) -1);
5910 dyn = htab->root.dynamic_sections_created;
5911 tls_type = ((struct elf_nds32_link_hash_entry *) h)->tls_type;
5912 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
5913 && (!bfd_link_pic (info)
5914 || !SYMBOL_REFERENCES_LOCAL (info, h)))
5915 indx = h->dynindx;
5916 }
5917 else
5918 {
5919 BFD_ASSERT (local_got_offsets != NULL
5920 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5921 off = local_got_offsets[r_symndx];
5922 tls_type = elf32_nds32_local_got_tls_type (input_bfd)[r_symndx];
5923 }
5924
5925 relocation = sgot->output_section->vma + sgot->output_offset + off;
5926
5927 if (1 < ones32 (tls_type))
5928 {
5929 eff_tls_type = 1 << (fls (tls_type) - 1);
5930 /* TLS model shall be handled in nds32_elf_unify_tls_model (). */
5931
5932 /* TLS model X -> LE is not implement yet!
5933 workaround here! */
5934 if (eff_tls_type == GOT_TLS_LE)
5935 {
5936 eff_tls_type = 1 << (fls (tls_type ^ eff_tls_type) - 1);
5937 }
5938 }
5939
5940 /* The offset must always be a multiple of 4. We use
5941 the least significant bit to record whether we have
5942 already processed this entry. */
5943 bfd_boolean need_relocs = FALSE;
5944 srelgot = ehtab->srelgot;
5945 if ((bfd_link_pic (info) || indx != 0)
5946 && (h == NULL || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5947 || h->root.type != bfd_link_hash_undefweak))
5948 {
5949 need_relocs = TRUE;
5950 BFD_ASSERT (srelgot != NULL);
5951 }
5952
5953 if (off & 1)
5954 {
5955 off &= ~1;
5956 relocation &= ~1;
5957
5958 if (eff_tls_type & GOT_TLS_DESC)
5959 {
5960 relocation -= elf_gp (output_bfd);
5961 if ((R_NDS32_TLS_DESC_HI20 == r_type) && (!need_relocs))
5962 {
5963 /* TLS model shall be converted. */
5964 BFD_ASSERT(0);
5965 }
5966 }
5967 else if (eff_tls_type & GOT_TLS_IEGP)
5968 {
5969 relocation -= elf_gp (output_bfd);
5970 }
5971 }
5972 else
5973 {
5974 if ((eff_tls_type & GOT_TLS_LE) && (tls_type ^ eff_tls_type))
5975 {
5976 /* TLS model workaround shall be applied. */
5977 BFD_ASSERT(0);
5978 }
5979 else if (eff_tls_type & (GOT_TLS_IE | GOT_TLS_IEGP))
5980 {
5981 if (eff_tls_type & GOT_TLS_IEGP)
5982 relocation -= elf_gp(output_bfd);
5983
5984 if (need_relocs)
5985 {
5986 if (indx == 0)
5987 outrel.r_addend = gottpoff (info, relocation_sym);
5988 else
5989 outrel.r_addend = 0;
5990 outrel.r_offset = (sgot->output_section->vma
5991 + sgot->output_offset + off);
5992 outrel.r_info = ELF32_R_INFO (indx, R_NDS32_TLS_TPOFF);
5993
5994 elf32_nds32_add_dynreloc (output_bfd, info, srelgot,
5995 &outrel);
5996 }
5997 else
5998 {
5999 bfd_put_32 (output_bfd, gottpoff (info, relocation_sym),
6000 sgot->contents + off);
6001 }
6002 }
6003 else if (eff_tls_type & GOT_TLS_DESC)
6004 {
6005 relocation -= elf_gp (output_bfd);
6006 if (need_relocs)
6007 {
6008 if (indx == 0)
6009 outrel.r_addend = gottpoff (info, relocation_sym);
6010 else
6011 outrel.r_addend = 0;
6012 outrel.r_offset = (sgot->output_section->vma
6013 + sgot->output_offset + off);
6014 outrel.r_info = ELF32_R_INFO (indx, R_NDS32_TLS_DESC);
6015
6016 if (htab->tls_desc_trampoline)
6017 {
6018 asection *srelplt;
6019 srelplt = ehtab->srelplt;
6020 loc = srelplt->contents;
6021 loc += htab->next_tls_desc_index++ * sizeof (Elf32_External_Rela);
6022 BFD_ASSERT (loc + sizeof (Elf32_External_Rela)
6023 <= srelplt->contents + srelplt->size);
6024
6025 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
6026 }
6027 else
6028 {
6029 loc = srelgot->contents;
6030 loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
6031 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
6032 ++srelgot->reloc_count;
6033 }
6034 }
6035 else
6036 {
6037 /* feed me! */
6038 bfd_put_32 (output_bfd, 0xdeadbeef,
6039 sgot->contents + off);
6040 bfd_put_32 (output_bfd, gottpoff (info, relocation_sym),
6041 sgot->contents + off + 4);
6042 patch_tls_desc_to_ie (contents, rel, input_bfd);
6043 BFD_ASSERT(0);
6044 }
6045 }
6046 else
6047 {
6048 /* TLS model workaround shall be applied. */
6049 BFD_ASSERT(0);
6050 }
6051
6052 if (h != NULL)
6053 h->got.offset |= 1;
6054 else
6055 local_got_offsets[r_symndx] |= 1;
6056 }
6057 }
6058 break;
6059 /* DON'T fall through. */
6060
6061 default:
6062 /* OLD_NDS32_RELOC. */
6063
6064 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
6065 contents, offset, relocation, addend);
6066 goto check_reloc;
6067 }
6068
6069 switch ((int) r_type)
6070 {
6071 case R_NDS32_20_RELA:
6072 case R_NDS32_5_RELA:
6073 case R_NDS32_9_PCREL_RELA:
6074 case R_NDS32_WORD_9_PCREL_RELA:
6075 case R_NDS32_10_UPCREL_RELA:
6076 case R_NDS32_15_PCREL_RELA:
6077 case R_NDS32_17_PCREL_RELA:
6078 case R_NDS32_25_PCREL_RELA:
6079 case R_NDS32_25_ABS_RELA:
6080 case R_NDS32_HI20_RELA:
6081 case R_NDS32_LO12S3_RELA:
6082 case R_NDS32_LO12S2_RELA:
6083 case R_NDS32_LO12S2_DP_RELA:
6084 case R_NDS32_LO12S2_SP_RELA:
6085 case R_NDS32_LO12S1_RELA:
6086 case R_NDS32_LO12S0_RELA:
6087 case R_NDS32_LO12S0_ORI_RELA:
6088 case R_NDS32_SDA16S3_RELA:
6089 case R_NDS32_SDA17S2_RELA:
6090 case R_NDS32_SDA18S1_RELA:
6091 case R_NDS32_SDA19S0_RELA:
6092 case R_NDS32_SDA15S3_RELA:
6093 case R_NDS32_SDA15S2_RELA:
6094 case R_NDS32_SDA12S2_DP_RELA:
6095 case R_NDS32_SDA12S2_SP_RELA:
6096 case R_NDS32_SDA15S1_RELA:
6097 case R_NDS32_SDA15S0_RELA:
6098 case R_NDS32_SDA_FP7U2_RELA:
6099 case R_NDS32_9_PLTREL:
6100 case R_NDS32_25_PLTREL:
6101 case R_NDS32_GOT20:
6102 case R_NDS32_GOT_HI20:
6103 case R_NDS32_GOT_LO12:
6104 case R_NDS32_GOT_LO15:
6105 case R_NDS32_GOT_LO19:
6106 case R_NDS32_GOT15S2_RELA:
6107 case R_NDS32_GOT17S2_RELA:
6108 case R_NDS32_GOTPC20:
6109 case R_NDS32_GOTPC_HI20:
6110 case R_NDS32_GOTPC_LO12:
6111 case R_NDS32_GOTOFF:
6112 case R_NDS32_GOTOFF_HI20:
6113 case R_NDS32_GOTOFF_LO12:
6114 case R_NDS32_GOTOFF_LO15:
6115 case R_NDS32_GOTOFF_LO19:
6116 case R_NDS32_PLTREL_HI20:
6117 case R_NDS32_PLTREL_LO12:
6118 case R_NDS32_PLT_GOTREL_HI20:
6119 case R_NDS32_PLT_GOTREL_LO12:
6120 case R_NDS32_PLT_GOTREL_LO15:
6121 case R_NDS32_PLT_GOTREL_LO19:
6122 case R_NDS32_PLT_GOTREL_LO20:
6123 case R_NDS32_17IFC_PCREL_RELA:
6124 case R_NDS32_10IFCU_PCREL_RELA:
6125 case R_NDS32_TLS_LE_HI20:
6126 case R_NDS32_TLS_LE_LO12:
6127 case R_NDS32_TLS_IE_HI20:
6128 case R_NDS32_TLS_IE_LO12S2:
6129 case R_NDS32_TLS_LE_20:
6130 case R_NDS32_TLS_LE_15S0:
6131 case R_NDS32_TLS_LE_15S1:
6132 case R_NDS32_TLS_LE_15S2:
6133 case R_NDS32_TLS_DESC_HI20:
6134 case R_NDS32_TLS_DESC_LO12:
6135 case R_NDS32_TLS_IE_LO12:
6136 case R_NDS32_TLS_IEGP_HI20:
6137 case R_NDS32_TLS_IEGP_LO12:
6138 case R_NDS32_TLS_IEGP_LO12S2:
6139 /* Instruction related relocs must handle endian properly. */
6140 /* NOTE: PIC IS NOT HANDLE YET; DO IT LATER. */
6141 r = nds32_elf_final_link_relocate (howto, input_bfd,
6142 input_section, contents,
6143 rel->r_offset, relocation,
6144 rel->r_addend);
6145 break;
6146
6147 default:
6148 /* All other relocs can use default handler. */
6149 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
6150 contents, rel->r_offset,
6151 relocation, rel->r_addend);
6152 break;
6153 }
6154
6155 check_reloc:
6156
6157 if (r != bfd_reloc_ok)
6158 {
6159 /* FIXME: This should be generic enough to go in a utility. */
6160 const char *name;
6161
6162 if (h != NULL)
6163 name = h->root.root.string;
6164 else
6165 {
6166 name = bfd_elf_string_from_elf_section
6167 (input_bfd, symtab_hdr->sh_link, sym->st_name);
6168 if (name == NULL || *name == '\0')
6169 name = bfd_section_name (input_bfd, sec);
6170 }
6171
6172 if (errmsg != NULL)
6173 goto common_error;
6174
6175 switch (r)
6176 {
6177 case bfd_reloc_overflow:
6178 (*info->callbacks->reloc_overflow)
6179 (info, (h ? &h->root : NULL), name, howto->name,
6180 (bfd_vma) 0, input_bfd, input_section, offset);
6181 break;
6182
6183 case bfd_reloc_undefined:
6184 (*info->callbacks->undefined_symbol)
6185 (info, name, input_bfd, input_section, offset, TRUE);
6186 break;
6187
6188 case bfd_reloc_outofrange:
6189 errmsg = _("internal error: out of range error");
6190 goto common_error;
6191
6192 case bfd_reloc_notsupported:
6193 errmsg = _("internal error: unsupported relocation error");
6194 goto common_error;
6195
6196 case bfd_reloc_dangerous:
6197 errmsg = _("internal error: dangerous error");
6198 goto common_error;
6199
6200 default:
6201 errmsg = _("internal error: unknown error");
6202 /* Fall through. */
6203
6204 common_error:
6205 (*info->callbacks->warning) (info, errmsg, name, input_bfd,
6206 input_section, offset);
6207 break;
6208 }
6209 }
6210 }
6211
6212 /* Resotre header size to avoid overflow load. */
6213 if (elf_nds32_tdata (input_bfd)->hdr_size != 0)
6214 symtab_hdr->sh_size = elf_nds32_tdata (input_bfd)->hdr_size;
6215
6216 return ret;
6217 }
6218
6219 /* Finish up dynamic symbol handling. We set the contents of various
6220 dynamic sections here. */
6221
6222 static bfd_boolean
6223 nds32_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
6224 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)
6225 {
6226 struct elf_link_hash_table *ehtab;
6227 struct elf_nds32_link_hash_entry *hent;
6228 bfd_byte *loc;
6229
6230 ehtab = elf_hash_table (info);
6231 hent = (struct elf_nds32_link_hash_entry *) h;
6232
6233 if (h->plt.offset != (bfd_vma) - 1)
6234 {
6235 asection *splt;
6236 asection *sgot;
6237 asection *srela;
6238
6239 bfd_vma plt_index;
6240 bfd_vma got_offset;
6241 bfd_vma local_plt_offset;
6242 Elf_Internal_Rela rela;
6243
6244 /* This symbol has an entry in the procedure linkage table. Set
6245 it up. */
6246
6247 BFD_ASSERT (h->dynindx != -1);
6248
6249 splt = ehtab->splt;
6250 sgot = ehtab->sgotplt;
6251 srela = ehtab->srelplt;
6252 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
6253
6254 /* Get the index in the procedure linkage table which
6255 corresponds to this symbol. This is the index of this symbol
6256 in all the symbols for which we are making plt entries. The
6257 first entry in the procedure linkage table is reserved. */
6258 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
6259
6260 /* Get the offset into the .got table of the entry that
6261 corresponds to this function. Each .got entry is 4 bytes.
6262 The first three are reserved. */
6263 got_offset = (plt_index + 3) * 4;
6264
6265 /* Fill in the entry in the procedure linkage table. */
6266 if (!bfd_link_pic (info))
6267 {
6268 unsigned long insn;
6269
6270 insn = PLT_ENTRY_WORD0 + (((sgot->output_section->vma
6271 + sgot->output_offset + got_offset) >> 12)
6272 & 0xfffff);
6273 bfd_putb32 (insn, splt->contents + h->plt.offset);
6274
6275 insn = PLT_ENTRY_WORD1 + (((sgot->output_section->vma
6276 + sgot->output_offset + got_offset) & 0x0fff)
6277 >> 2);
6278 bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
6279
6280 insn = PLT_ENTRY_WORD2;
6281 bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
6282
6283 insn = PLT_ENTRY_WORD3 + (plt_index & 0x7ffff);
6284 bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
6285
6286 insn = PLT_ENTRY_WORD4
6287 + (((unsigned int) ((-(h->plt.offset + 16)) >> 1)) & 0xffffff);
6288 bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
6289 local_plt_offset = 12;
6290 }
6291 else
6292 {
6293 /* sda_base must be set at this time. */
6294 unsigned long insn;
6295 long offset;
6296
6297 offset = sgot->output_section->vma + sgot->output_offset + got_offset
6298 - elf_gp (output_bfd);
6299 insn = PLT_PIC_ENTRY_WORD0 + ((offset >> 12) & 0xfffff);
6300 bfd_putb32 (insn, splt->contents + h->plt.offset);
6301
6302 insn = PLT_PIC_ENTRY_WORD1 + (offset & 0xfff);
6303 bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
6304
6305 insn = PLT_PIC_ENTRY_WORD2;
6306 bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
6307
6308 insn = PLT_PIC_ENTRY_WORD3;
6309 bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
6310
6311 insn = PLT_PIC_ENTRY_WORD4 + (plt_index & 0x7fffff);
6312 bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
6313
6314 insn = PLT_PIC_ENTRY_WORD5
6315 + (((unsigned int) ((-(h->plt.offset + 20)) >> 1)) & 0xffffff);
6316 bfd_putb32 (insn, splt->contents + h->plt.offset + 20);
6317
6318 local_plt_offset = 16;
6319 }
6320
6321 /* Fill in the entry in the global offset table,
6322 so it will fall through to the next instruction for the first time. */
6323 bfd_put_32 (output_bfd,
6324 (splt->output_section->vma + splt->output_offset
6325 + h->plt.offset + local_plt_offset),
6326 sgot->contents + got_offset);
6327
6328 /* Fill in the entry in the .rela.plt section. */
6329 rela.r_offset = (sgot->output_section->vma
6330 + sgot->output_offset + got_offset);
6331 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_JMP_SLOT);
6332 rela.r_addend = 0;
6333 loc = srela->contents;
6334 loc += plt_index * sizeof (Elf32_External_Rela);
6335 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
6336
6337 if (!h->def_regular)
6338 {
6339 /* Mark the symbol as undefined, rather than as defined in
6340 the .plt section. Leave the value alone. */
6341 sym->st_shndx = SHN_UNDEF;
6342 if (!h->ref_regular_nonweak)
6343 sym->st_value = 0;
6344 }
6345 }
6346
6347 if (h->got.offset != (bfd_vma) - 1
6348 && hent->tls_type == GOT_NORMAL)
6349 {
6350 asection *sgot;
6351 asection *srelagot;
6352 Elf_Internal_Rela rela;
6353
6354 /* This symbol has an entry in the global offset table.
6355 Set it up. */
6356
6357 sgot = ehtab->sgot;
6358 srelagot = ehtab->srelgot;
6359 BFD_ASSERT (sgot != NULL && srelagot != NULL);
6360
6361 rela.r_offset = (sgot->output_section->vma
6362 + sgot->output_offset + (h->got.offset & ~1));
6363
6364 /* If this is a -Bsymbolic link, and the symbol is defined
6365 locally, we just want to emit a RELATIVE reloc. Likewise if
6366 the symbol was forced to be local because of a version file.
6367 The entry in the global offset table will already have been
6368 initialized in the relocate_section function. */
6369 if ((bfd_link_pic (info)
6370 && (info->symbolic || h->dynindx == -1 || h->forced_local)
6371 && h->def_regular)
6372 || (bfd_link_pie (info) && h->def_regular))
6373 {
6374 rela.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
6375 rela.r_addend = (h->root.u.def.value
6376 + h->root.u.def.section->output_section->vma
6377 + h->root.u.def.section->output_offset);
6378
6379 if ((h->got.offset & 1) == 0)
6380 {
6381 bfd_put_32 (output_bfd, rela.r_addend,
6382 sgot->contents + h->got.offset);
6383 }
6384 }
6385 else
6386 {
6387 BFD_ASSERT ((h->got.offset & 1) == 0);
6388 bfd_put_32 (output_bfd, (bfd_vma) 0,
6389 sgot->contents + h->got.offset);
6390 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_GLOB_DAT);
6391 rela.r_addend = 0;
6392 }
6393
6394 loc = srelagot->contents;
6395 loc += srelagot->reloc_count * sizeof (Elf32_External_Rela);
6396 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
6397 ++srelagot->reloc_count;
6398 BFD_ASSERT (loc < (srelagot->contents + srelagot->size));
6399 }
6400
6401 if (h->needs_copy)
6402 {
6403 asection *s;
6404 Elf_Internal_Rela rela;
6405
6406 /* This symbols needs a copy reloc. Set it up. */
6407
6408 BFD_ASSERT (h->dynindx != -1
6409 && (h->root.type == bfd_link_hash_defined
6410 || h->root.type == bfd_link_hash_defweak));
6411
6412 s = bfd_get_section_by_name (h->root.u.def.section->owner, ".rela.bss");
6413 BFD_ASSERT (s != NULL);
6414
6415 rela.r_offset = (h->root.u.def.value
6416 + h->root.u.def.section->output_section->vma
6417 + h->root.u.def.section->output_offset);
6418 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_COPY);
6419 rela.r_addend = 0;
6420 loc = s->contents;
6421 loc += s->reloc_count * sizeof (Elf32_External_Rela);
6422 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
6423 ++s->reloc_count;
6424 }
6425
6426 /* Mark some specially defined symbols as absolute. */
6427 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
6428 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
6429 sym->st_shndx = SHN_ABS;
6430
6431 return TRUE;
6432 }
6433
6434
6435 /* Finish up the dynamic sections. */
6436
6437 static bfd_boolean
6438 nds32_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
6439 {
6440 bfd *dynobj;
6441 asection *sdyn;
6442 asection *sgotplt;
6443 struct elf_link_hash_table *ehtab;
6444 struct elf_nds32_link_hash_table *htab;
6445
6446 ehtab = elf_hash_table (info);
6447 htab = nds32_elf_hash_table (info);
6448 if (htab == NULL)
6449 return FALSE;
6450
6451 dynobj = elf_hash_table (info)->dynobj;
6452
6453 sgotplt = ehtab->sgotplt;
6454 /* A broken linker script might have discarded the dynamic sections.
6455 Catch this here so that we do not seg-fault later on. */
6456 if (sgotplt != NULL && bfd_is_abs_section (sgotplt->output_section))
6457 return FALSE;
6458 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
6459
6460 if (elf_hash_table (info)->dynamic_sections_created)
6461 {
6462 asection *splt;
6463 Elf32_External_Dyn *dyncon, *dynconend;
6464
6465 BFD_ASSERT (sgotplt != NULL && sdyn != NULL);
6466
6467 dyncon = (Elf32_External_Dyn *) sdyn->contents;
6468 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
6469
6470 for (; dyncon < dynconend; dyncon++)
6471 {
6472 Elf_Internal_Dyn dyn;
6473 asection *s;
6474
6475 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
6476
6477 switch (dyn.d_tag)
6478 {
6479 default:
6480 break;
6481
6482 case DT_PLTGOT:
6483 /* name = ".got"; */
6484 s = ehtab->sgot->output_section;
6485 goto get_vma;
6486 case DT_JMPREL:
6487 s = ehtab->srelplt->output_section;
6488 get_vma:
6489 BFD_ASSERT (s != NULL);
6490 dyn.d_un.d_ptr = s->vma;
6491 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6492 break;
6493
6494 case DT_PLTRELSZ:
6495 s = ehtab->srelplt->output_section;
6496 BFD_ASSERT (s != NULL);
6497 dyn.d_un.d_val = s->size;
6498 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6499 break;
6500
6501 case DT_RELASZ:
6502 /* My reading of the SVR4 ABI indicates that the
6503 procedure linkage table relocs (DT_JMPREL) should be
6504 included in the overall relocs (DT_RELA). This is
6505 what Solaris does. However, UnixWare can not handle
6506 that case. Therefore, we override the DT_RELASZ entry
6507 here to make it not include the JMPREL relocs. Since
6508 the linker script arranges for .rela.plt to follow all
6509 other relocation sections, we don't have to worry
6510 about changing the DT_RELA entry. */
6511 if (ehtab->srelplt != NULL)
6512 {
6513 s = ehtab->srelplt->output_section;
6514 dyn.d_un.d_val -= s->size;
6515 }
6516 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6517 break;
6518
6519 case DT_TLSDESC_PLT:
6520 s = htab->root.splt;
6521 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
6522 + htab->dt_tlsdesc_plt);
6523 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6524 break;
6525
6526 case DT_TLSDESC_GOT:
6527 s = htab->root.sgot;
6528 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
6529 + htab->dt_tlsdesc_got);
6530 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6531 break;
6532 }
6533 }
6534
6535 /* Fill in the first entry in the procedure linkage table. */
6536 splt = ehtab->splt;
6537 if (splt && splt->size > 0)
6538 {
6539 if (bfd_link_pic (info))
6540 {
6541 unsigned long insn;
6542 long offset;
6543
6544 offset = sgotplt->output_section->vma + sgotplt->output_offset + 4
6545 - elf_gp (output_bfd);
6546 insn = PLT0_PIC_ENTRY_WORD0 | ((offset >> 12) & 0xfffff);
6547 bfd_putb32 (insn, splt->contents);
6548
6549 /* here has a typo? */
6550 insn = PLT0_PIC_ENTRY_WORD1 | (offset & 0xfff);
6551 bfd_putb32 (insn, splt->contents + 4);
6552
6553 insn = PLT0_PIC_ENTRY_WORD2;
6554 bfd_putb32 (insn, splt->contents + 8);
6555
6556 insn = PLT0_PIC_ENTRY_WORD3;
6557 bfd_putb32 (insn, splt->contents + 12);
6558
6559 insn = PLT0_PIC_ENTRY_WORD4;
6560 bfd_putb32 (insn, splt->contents + 16);
6561
6562 insn = PLT0_PIC_ENTRY_WORD5;
6563 bfd_putb32 (insn, splt->contents + 20);
6564 }
6565 else
6566 {
6567 unsigned long insn;
6568 unsigned long addr;
6569
6570 /* addr = .got + 4 */
6571 addr = sgotplt->output_section->vma + sgotplt->output_offset + 4;
6572 insn = PLT0_ENTRY_WORD0 | ((addr >> 12) & 0xfffff);
6573 bfd_putb32 (insn, splt->contents);
6574
6575 insn = PLT0_ENTRY_WORD1 | (addr & 0x0fff);
6576 bfd_putb32 (insn, splt->contents + 4);
6577
6578 insn = PLT0_ENTRY_WORD2;
6579 bfd_putb32 (insn, splt->contents + 8);
6580
6581 insn = PLT0_ENTRY_WORD3;
6582 bfd_putb32 (insn, splt->contents + 12);
6583
6584 insn = PLT0_ENTRY_WORD4;
6585 bfd_putb32 (insn, splt->contents + 16);
6586 }
6587
6588 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
6589 PLT_ENTRY_SIZE;
6590 }
6591
6592 if (htab->dt_tlsdesc_plt)
6593 {
6594 /* Calculate addresses. */
6595 asection *sgot = sgot = ehtab->sgot;
6596 bfd_vma pltgot = sgotplt->output_section->vma
6597 + sgotplt->output_offset;
6598 bfd_vma tlsdesc_got = sgot->output_section->vma + sgot->output_offset
6599 + htab->dt_tlsdesc_got;
6600
6601 /* Get GP offset. */
6602 pltgot -= elf_gp (output_bfd) - 4; /* PLTGOT[1] */
6603 tlsdesc_got -= elf_gp (output_bfd);
6604
6605 /* Do relocation. */
6606 dl_tlsdesc_lazy_trampoline[0] += ((1 << 20) - 1) & (tlsdesc_got >> 12);
6607 dl_tlsdesc_lazy_trampoline[1] += 0xfff & tlsdesc_got;
6608 dl_tlsdesc_lazy_trampoline[4] += ((1 << 20) - 1) & (pltgot >> 12);
6609 dl_tlsdesc_lazy_trampoline[5] += 0xfff & pltgot;
6610
6611 /* Insert .plt. */
6612 nds32_put_trampoline (splt->contents + htab->dt_tlsdesc_plt,
6613 dl_tlsdesc_lazy_trampoline,
6614 ARRAY_SIZE (dl_tlsdesc_lazy_trampoline));
6615 }
6616 }
6617
6618 /* Fill in the first three entries in the global offset table. */
6619 if (sgotplt && sgotplt->size > 0)
6620 {
6621 if (sdyn == NULL)
6622 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
6623 else
6624 bfd_put_32 (output_bfd,
6625 sdyn->output_section->vma + sdyn->output_offset,
6626 sgotplt->contents);
6627 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
6628 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
6629
6630 elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
6631 }
6632
6633 return TRUE;
6634 }
6635 \f
6636
6637 /* Set the right machine number. */
6638
6639 static bfd_boolean
6640 nds32_elf_object_p (bfd *abfd)
6641 {
6642 static unsigned int cur_arch = 0;
6643
6644 if (E_N1_ARCH != (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH))
6645 {
6646 /* E_N1_ARCH is a wild card, so it is set only when no others exist. */
6647 cur_arch = (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH);
6648 }
6649
6650 switch (cur_arch)
6651 {
6652 default:
6653 case E_N1_ARCH:
6654 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1);
6655 break;
6656 case E_N1H_ARCH:
6657 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h);
6658 break;
6659 case E_NDS_ARCH_STAR_V2_0:
6660 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v2);
6661 break;
6662 case E_NDS_ARCH_STAR_V3_0:
6663 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3);
6664 break;
6665 case E_NDS_ARCH_STAR_V3_M:
6666 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3m);
6667 break;
6668 }
6669
6670 return TRUE;
6671 }
6672
6673 /* Store the machine number in the flags field. */
6674
6675 static void
6676 nds32_elf_final_write_processing (bfd *abfd,
6677 bfd_boolean linker ATTRIBUTE_UNUSED)
6678 {
6679 unsigned long val;
6680 static unsigned int cur_mach = 0;
6681
6682 if (bfd_mach_n1 != bfd_get_mach (abfd))
6683 {
6684 cur_mach = bfd_get_mach (abfd);
6685 }
6686
6687 switch (cur_mach)
6688 {
6689 case bfd_mach_n1:
6690 /* Only happen when object is empty, since the case is abandon. */
6691 val = E_N1_ARCH;
6692 val |= E_NDS_ABI_AABI;
6693 val |= E_NDS32_ELF_VER_1_4;
6694 break;
6695 case bfd_mach_n1h:
6696 val = E_N1H_ARCH;
6697 break;
6698 case bfd_mach_n1h_v2:
6699 val = E_NDS_ARCH_STAR_V2_0;
6700 break;
6701 case bfd_mach_n1h_v3:
6702 val = E_NDS_ARCH_STAR_V3_0;
6703 break;
6704 case bfd_mach_n1h_v3m:
6705 val = E_NDS_ARCH_STAR_V3_M;
6706 break;
6707 default:
6708 val = 0;
6709 break;
6710 }
6711
6712 elf_elfheader (abfd)->e_flags &= ~EF_NDS_ARCH;
6713 elf_elfheader (abfd)->e_flags |= val;
6714 }
6715
6716 /* Function to keep NDS32 specific file flags. */
6717
6718 static bfd_boolean
6719 nds32_elf_set_private_flags (bfd *abfd, flagword flags)
6720 {
6721 BFD_ASSERT (!elf_flags_init (abfd)
6722 || elf_elfheader (abfd)->e_flags == flags);
6723
6724 elf_elfheader (abfd)->e_flags = flags;
6725 elf_flags_init (abfd) = TRUE;
6726 return TRUE;
6727 }
6728
6729 static unsigned int
6730 convert_e_flags (unsigned int e_flags, unsigned int arch)
6731 {
6732 if ((e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9)
6733 {
6734 /* From 0.9 to 1.0. */
6735 e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V1_0;
6736
6737 /* Invert E_NDS32_HAS_NO_MAC_INST. */
6738 e_flags ^= E_NDS32_HAS_NO_MAC_INST;
6739 if (arch == E_NDS_ARCH_STAR_V1_0)
6740 {
6741 /* Done. */
6742 return e_flags;
6743 }
6744 }
6745
6746 /* From 1.0 to 2.0. */
6747 e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V2_0;
6748
6749 /* Clear E_NDS32_HAS_MFUSR_PC_INST. */
6750 e_flags &= ~E_NDS32_HAS_MFUSR_PC_INST;
6751
6752 /* Invert E_NDS32_HAS_NO_MAC_INST. */
6753 e_flags ^= E_NDS32_HAS_NO_MAC_INST;
6754 return e_flags;
6755 }
6756
6757 static bfd_boolean
6758 nds32_check_vec_size (bfd *ibfd)
6759 {
6760 static unsigned int nds32_vec_size = 0;
6761
6762 asection *sec_t = NULL;
6763 bfd_byte *contents = NULL;
6764
6765 sec_t = bfd_get_section_by_name (ibfd, ".nds32_e_flags");
6766
6767 if (sec_t && sec_t->size >= 4)
6768 {
6769 /* Get vec_size in file. */
6770 unsigned int flag_t;
6771
6772 nds32_get_section_contents (ibfd, sec_t, &contents, TRUE);
6773 flag_t = bfd_get_32 (ibfd, contents);
6774
6775 /* The value could only be 4 or 16. */
6776
6777 if (!nds32_vec_size)
6778 /* Set if not set yet. */
6779 nds32_vec_size = (flag_t & 0x3);
6780 else if (nds32_vec_size != (flag_t & 0x3))
6781 {
6782 _bfd_error_handler
6783 /* xgettext:c-format */
6784 (_("%pB: ISR vector size mismatch"
6785 " with previous modules, previous %u-byte, current %u-byte"),
6786 ibfd,
6787 nds32_vec_size == 1 ? 4 : nds32_vec_size == 2 ? 16 : 0xffffffff,
6788 (flag_t & 0x3) == 1 ? 4 : (flag_t & 0x3) == 2 ? 16 : 0xffffffff);
6789 return FALSE;
6790 }
6791 else
6792 /* Only keep the first vec_size section. */
6793 sec_t->flags |= SEC_EXCLUDE;
6794 }
6795
6796 return TRUE;
6797 }
6798
6799 /* Merge backend specific data from an object file to the output
6800 object file when linking. */
6801
6802 static bfd_boolean
6803 nds32_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6804 {
6805 bfd *obfd = info->output_bfd;
6806 flagword out_flags;
6807 flagword in_flags;
6808 flagword out_16regs;
6809 flagword in_no_mac;
6810 flagword out_no_mac;
6811 flagword in_16regs;
6812 flagword out_version;
6813 flagword in_version;
6814 flagword out_fpu_config;
6815 flagword in_fpu_config;
6816
6817 /* TODO: Revise to use object-attributes instead. */
6818 if (!nds32_check_vec_size (ibfd))
6819 return FALSE;
6820
6821 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6822 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6823 return TRUE;
6824
6825 if (bfd_little_endian (ibfd) != bfd_little_endian (obfd))
6826 {
6827 _bfd_error_handler
6828 (_("%pB: warning: endian mismatch with previous modules"), ibfd);
6829
6830 bfd_set_error (bfd_error_bad_value);
6831 return FALSE;
6832 }
6833
6834 /* -B option in objcopy cannot work as expected. e_flags = 0 shall be
6835 treat as generic one without checking and merging. */
6836 if (elf_elfheader (ibfd)->e_flags)
6837 {
6838 in_version = elf_elfheader (ibfd)->e_flags & EF_NDS32_ELF_VERSION;
6839 if (in_version == E_NDS32_ELF_VER_1_2)
6840 {
6841 _bfd_error_handler
6842 (_("%pB: warning: older version of object file encountered, "
6843 "please recompile with current tool chain"), ibfd);
6844 }
6845
6846 /* We may need to merge V1 and V2 arch object files to V2. */
6847 if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6848 != (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6849 {
6850 /* Need to convert version. */
6851 if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6852 == E_NDS_ARCH_STAR_RESERVED)
6853 {
6854 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6855 }
6856 else if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6857 == E_NDS_ARCH_STAR_V3_M
6858 && (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH)
6859 == E_NDS_ARCH_STAR_V3_0)
6860 {
6861 elf_elfheader (ibfd)->e_flags =
6862 (elf_elfheader (ibfd)->e_flags & (~EF_NDS_ARCH))
6863 | E_NDS_ARCH_STAR_V3_0;
6864 }
6865 else if ((elf_elfheader (obfd)->e_flags & EF_NDS_ARCH)
6866 == E_NDS_ARCH_STAR_V0_9
6867 || (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6868 > (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6869 {
6870 elf_elfheader (obfd)->e_flags =
6871 convert_e_flags (elf_elfheader (obfd)->e_flags,
6872 (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH));
6873 }
6874 else
6875 {
6876 elf_elfheader (ibfd)->e_flags =
6877 convert_e_flags (elf_elfheader (ibfd)->e_flags,
6878 (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH));
6879 }
6880 }
6881
6882 /* Extract some flags. */
6883 in_flags = elf_elfheader (ibfd)->e_flags
6884 & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6885 | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6886
6887 /* The following flags need special treatment. */
6888 in_16regs = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6889 in_no_mac = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6890 in_fpu_config = elf_elfheader (ibfd)->e_flags & E_NDS32_FPU_REG_CONF;
6891
6892 /* Extract some flags. */
6893 out_flags = elf_elfheader (obfd)->e_flags
6894 & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6895 | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6896
6897 /* The following flags need special treatment. */
6898 out_16regs = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6899 out_no_mac = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6900 out_fpu_config = elf_elfheader (obfd)->e_flags & E_NDS32_FPU_REG_CONF;
6901 out_version = elf_elfheader (obfd)->e_flags & EF_NDS32_ELF_VERSION;
6902 if (!elf_flags_init (obfd))
6903 {
6904 /* If the input is the default architecture then do not
6905 bother setting the flags for the output architecture,
6906 instead allow future merges to do this. If no future
6907 merges ever set these flags then they will retain their
6908 unitialised values, which surprise surprise, correspond
6909 to the default values. */
6910 if (bfd_get_arch_info (ibfd)->the_default)
6911 return TRUE;
6912
6913 elf_flags_init (obfd) = TRUE;
6914 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6915
6916 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
6917 && bfd_get_arch_info (obfd)->the_default)
6918 {
6919 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
6920 bfd_get_mach (ibfd));
6921 }
6922
6923 return TRUE;
6924 }
6925
6926 /* Check flag compatibility. */
6927 if ((in_flags & EF_NDS_ABI) != (out_flags & EF_NDS_ABI))
6928 {
6929 _bfd_error_handler
6930 (_("%pB: error: ABI mismatch with previous modules"), ibfd);
6931 bfd_set_error (bfd_error_bad_value);
6932 return FALSE;
6933 }
6934
6935 if ((in_flags & EF_NDS_ARCH) != (out_flags & EF_NDS_ARCH))
6936 {
6937 if (((in_flags & EF_NDS_ARCH) != E_N1_ARCH))
6938 {
6939 _bfd_error_handler
6940 (_("%pB: error: instruction set mismatch with previous modules"),
6941 ibfd);
6942
6943 bfd_set_error (bfd_error_bad_value);
6944 return FALSE;
6945 }
6946 }
6947
6948 /* When linking with V1.2 and V1.3 objects together the output is V1.2.
6949 and perf ext1 and DIV are mergerd to perf ext1. */
6950 if (in_version == E_NDS32_ELF_VER_1_2 || out_version == E_NDS32_ELF_VER_1_2)
6951 {
6952 elf_elfheader (obfd)->e_flags =
6953 (in_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6954 | (out_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6955 | (((in_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6956 ? E_NDS32_HAS_EXT_INST : 0)
6957 | (((out_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6958 ? E_NDS32_HAS_EXT_INST : 0)
6959 | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6960 | ((in_version > out_version) ? out_version : in_version);
6961 }
6962 else
6963 {
6964 if (in_version != out_version)
6965 _bfd_error_handler
6966 /* xgettext:c-format */
6967 (_("%pB: warning: incompatible elf-versions %s and %s"),
6968 ibfd, nds32_elfver_strtab[out_version],
6969 nds32_elfver_strtab[in_version]);
6970
6971 elf_elfheader (obfd)->e_flags = in_flags | out_flags
6972 | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6973 | (in_fpu_config > out_fpu_config ? in_fpu_config : out_fpu_config)
6974 | (in_version > out_version ? out_version : in_version);
6975 }
6976 }
6977
6978 return TRUE;
6979 }
6980
6981 /* Display the flags field. */
6982
6983 static bfd_boolean
6984 nds32_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6985 {
6986 FILE *file = (FILE *) ptr;
6987
6988 BFD_ASSERT (abfd != NULL && ptr != NULL);
6989
6990 _bfd_elf_print_private_bfd_data (abfd, ptr);
6991
6992 fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
6993
6994 switch (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH)
6995 {
6996 default:
6997 case E_N1_ARCH:
6998 fprintf (file, _(": n1 instructions"));
6999 break;
7000 case E_N1H_ARCH:
7001 fprintf (file, _(": n1h instructions"));
7002 break;
7003 }
7004
7005 fputc ('\n', file);
7006
7007 return TRUE;
7008 }
7009
7010 static unsigned int
7011 nds32_elf_action_discarded (asection *sec)
7012 {
7013
7014 if (strncmp
7015 (".gcc_except_table", sec->name, sizeof (".gcc_except_table") - 1) == 0)
7016 return 0;
7017
7018 return _bfd_elf_default_action_discarded (sec);
7019 }
7020
7021 static asection *
7022 nds32_elf_gc_mark_hook (asection *sec, struct bfd_link_info *info,
7023 Elf_Internal_Rela *rel, struct elf_link_hash_entry *h,
7024 Elf_Internal_Sym *sym)
7025 {
7026 if (h != NULL)
7027 switch (ELF32_R_TYPE (rel->r_info))
7028 {
7029 case R_NDS32_GNU_VTINHERIT:
7030 case R_NDS32_GNU_VTENTRY:
7031 case R_NDS32_RELA_GNU_VTINHERIT:
7032 case R_NDS32_RELA_GNU_VTENTRY:
7033 return NULL;
7034 }
7035
7036 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
7037 }
7038
7039 static enum elf_nds32_tls_type
7040 get_tls_type (enum elf_nds32_reloc_type r_type,
7041 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
7042 {
7043 enum elf_nds32_tls_type tls_type;
7044
7045 switch (r_type)
7046 {
7047 case R_NDS32_TLS_LE_HI20:
7048 case R_NDS32_TLS_LE_LO12:
7049 tls_type = GOT_TLS_LE;
7050 break;
7051 case R_NDS32_TLS_IE_HI20:
7052 case R_NDS32_TLS_IE_LO12S2:
7053 case R_NDS32_TLS_IE_LO12:
7054 tls_type = GOT_TLS_IE;
7055 break;
7056 case R_NDS32_TLS_IEGP_HI20:
7057 case R_NDS32_TLS_IEGP_LO12:
7058 case R_NDS32_TLS_IEGP_LO12S2:
7059 tls_type = GOT_TLS_IEGP;
7060 break;
7061 case R_NDS32_TLS_DESC_HI20:
7062 case R_NDS32_TLS_DESC_LO12:
7063 case R_NDS32_TLS_DESC_ADD:
7064 case R_NDS32_TLS_DESC_FUNC:
7065 case R_NDS32_TLS_DESC_CALL:
7066 tls_type = GOT_TLS_DESC;
7067 break;
7068 default:
7069 tls_type = GOT_NORMAL;
7070 break;
7071 }
7072
7073 return tls_type;
7074 }
7075
7076 /* Ensure that we have allocated bookkeeping structures for ABFD's local
7077 symbols. */
7078
7079 static bfd_boolean
7080 elf32_nds32_allocate_local_sym_info (bfd *abfd)
7081 {
7082 if (elf_local_got_refcounts (abfd) == NULL)
7083 {
7084 bfd_size_type num_syms;
7085 bfd_size_type size;
7086 char *data;
7087
7088 num_syms = elf_tdata (abfd)->symtab_hdr.sh_info;
7089 /* This space is for got_refcounts, got_tls_type, tlsdesc_gotent, and
7090 gp_offset. The details can refer to struct elf_nds32_obj_tdata. */
7091 size = num_syms * (sizeof (bfd_signed_vma) + sizeof (char)
7092 + sizeof (bfd_vma) + sizeof (int)
7093 + sizeof (bfd_boolean) + sizeof (bfd_vma));
7094 data = bfd_zalloc (abfd, size);
7095 if (data == NULL)
7096 return FALSE;
7097
7098 elf_local_got_refcounts (abfd) = (bfd_signed_vma *) data;
7099 data += num_syms * sizeof (bfd_signed_vma);
7100
7101 elf32_nds32_local_got_tls_type (abfd) = (char *) data;
7102 data += num_syms * sizeof (char);
7103
7104 elf32_nds32_local_tlsdesc_gotent (abfd) = (bfd_vma *) data;
7105 data += num_syms * sizeof (bfd_vma);
7106
7107 elf32_nds32_local_gp_offset (abfd) = (int *) data;
7108 data += num_syms * sizeof (int);
7109 }
7110
7111 return TRUE;
7112 }
7113
7114 /* Look through the relocs for a section during the first phase.
7115 Since we don't do .gots or .plts, we just need to consider the
7116 virtual table relocs for gc. */
7117
7118 static bfd_boolean
7119 nds32_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
7120 asection *sec, const Elf_Internal_Rela *relocs)
7121 {
7122 Elf_Internal_Shdr *symtab_hdr;
7123 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
7124 const Elf_Internal_Rela *rel;
7125 const Elf_Internal_Rela *rel_end;
7126 struct elf_link_hash_table *ehtab;
7127 struct elf_nds32_link_hash_table *htab;
7128 bfd *dynobj;
7129 asection *sreloc = NULL;
7130
7131 /* No need for relocation if relocatable already. */
7132 if (bfd_link_relocatable (info))
7133 {
7134 elf32_nds32_check_relax_group (abfd, sec);
7135 return TRUE;
7136 }
7137
7138 /* Don't do anything special with non-loaded, non-alloced sections.
7139 In particular, any relocs in such sections should not affect GOT
7140 and PLT reference counting (ie. we don't allow them to create GOT
7141 or PLT entries), there's no possibility or desire to optimize TLS
7142 relocs, and there's not much point in propagating relocs to shared
7143 libs that the dynamic linker won't relocate. */
7144 if ((sec->flags & SEC_ALLOC) == 0)
7145 return TRUE;
7146
7147 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7148 sym_hashes = elf_sym_hashes (abfd);
7149 sym_hashes_end =
7150 sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
7151 if (!elf_bad_symtab (abfd))
7152 sym_hashes_end -= symtab_hdr->sh_info;
7153
7154 ehtab = elf_hash_table (info);
7155 htab = nds32_elf_hash_table (info);
7156 dynobj = htab->root.dynobj;
7157
7158 rel_end = relocs + sec->reloc_count;
7159 for (rel = relocs; rel < rel_end; rel++)
7160 {
7161 enum elf_nds32_reloc_type r_type;
7162 struct elf_link_hash_entry *h;
7163 unsigned long r_symndx;
7164 enum elf_nds32_tls_type tls_type, old_tls_type;
7165
7166 r_symndx = ELF32_R_SYM (rel->r_info);
7167 r_type = ELF32_R_TYPE (rel->r_info);
7168 if (r_symndx < symtab_hdr->sh_info)
7169 h = NULL;
7170 else
7171 {
7172 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7173 while (h->root.type == bfd_link_hash_indirect
7174 || h->root.type == bfd_link_hash_warning)
7175 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7176 }
7177
7178 /* Create .got section if necessary.
7179 Some relocs require a global offset table. We create
7180 got section here, since these relocation need a got section
7181 and if it is not created yet. */
7182 if (ehtab->sgot == NULL)
7183 {
7184 switch (r_type)
7185 {
7186 case R_NDS32_GOT_HI20:
7187 case R_NDS32_GOT_LO12:
7188 case R_NDS32_GOT_LO15:
7189 case R_NDS32_GOT_LO19:
7190 case R_NDS32_GOT17S2_RELA:
7191 case R_NDS32_GOT15S2_RELA:
7192 case R_NDS32_GOTOFF:
7193 case R_NDS32_GOTOFF_HI20:
7194 case R_NDS32_GOTOFF_LO12:
7195 case R_NDS32_GOTOFF_LO15:
7196 case R_NDS32_GOTOFF_LO19:
7197 case R_NDS32_GOTPC20:
7198 case R_NDS32_GOTPC_HI20:
7199 case R_NDS32_GOTPC_LO12:
7200 case R_NDS32_GOT20:
7201 case R_NDS32_TLS_IE_HI20:
7202 case R_NDS32_TLS_IE_LO12:
7203 case R_NDS32_TLS_IE_LO12S2:
7204 case R_NDS32_TLS_IEGP_HI20:
7205 case R_NDS32_TLS_IEGP_LO12:
7206 case R_NDS32_TLS_IEGP_LO12S2:
7207 case R_NDS32_TLS_DESC_HI20:
7208 case R_NDS32_TLS_DESC_LO12:
7209 if (dynobj == NULL)
7210 htab->root.dynobj = dynobj = abfd;
7211 if (!create_got_section (dynobj, info))
7212 return FALSE;
7213 break;
7214
7215 default:
7216 break;
7217 }
7218 }
7219
7220 /* Check relocation type. */
7221 switch ((int) r_type)
7222 {
7223 case R_NDS32_GOT_HI20:
7224 case R_NDS32_GOT_LO12:
7225 case R_NDS32_GOT_LO15:
7226 case R_NDS32_GOT_LO19:
7227 case R_NDS32_GOT20:
7228 case R_NDS32_TLS_LE_HI20:
7229 case R_NDS32_TLS_LE_LO12:
7230 case R_NDS32_TLS_IE_HI20:
7231 case R_NDS32_TLS_IE_LO12:
7232 case R_NDS32_TLS_IE_LO12S2:
7233 case R_NDS32_TLS_IEGP_HI20:
7234 case R_NDS32_TLS_IEGP_LO12:
7235 case R_NDS32_TLS_IEGP_LO12S2:
7236 case R_NDS32_TLS_DESC_HI20:
7237 case R_NDS32_TLS_DESC_LO12:
7238 tls_type = get_tls_type (r_type, h);
7239 if (h)
7240 {
7241 if (tls_type != GOT_TLS_LE)
7242 h->got.refcount += 1;
7243 old_tls_type = elf32_nds32_hash_entry (h)->tls_type;
7244 }
7245 else
7246 {
7247 /* This is a global offset table entry for a local symbol. */
7248 if (!elf32_nds32_allocate_local_sym_info (abfd))
7249 return FALSE;
7250
7251 BFD_ASSERT (r_symndx < symtab_hdr->sh_info);
7252 if (tls_type != GOT_TLS_LE)
7253 elf_local_got_refcounts (abfd)[r_symndx] += 1;
7254 old_tls_type = elf32_nds32_local_got_tls_type (abfd)[r_symndx];
7255 }
7256
7257 /* We would already have issued an error message if there
7258 is a TLS/non-TLS mismatch, based on the symbol
7259 type. So just combine any TLS types needed. */
7260 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
7261 && tls_type != GOT_NORMAL)
7262 tls_type |= old_tls_type;
7263
7264 /* DESC to IE/IEGP if link to executable. */
7265 if ((tls_type & (GOT_TLS_DESC | GOT_TLS_IEGP))
7266 && (bfd_link_executable (info)))
7267 tls_type |= (bfd_link_pie (info) ? GOT_TLS_IEGP : GOT_TLS_IE);
7268
7269 if (old_tls_type != tls_type)
7270 {
7271 if (h != NULL)
7272 elf32_nds32_hash_entry (h)->tls_type = tls_type;
7273 else
7274 elf32_nds32_local_got_tls_type (abfd)[r_symndx] = tls_type;
7275 }
7276 break;
7277 case R_NDS32_9_PLTREL:
7278 case R_NDS32_25_PLTREL:
7279 case R_NDS32_PLTREL_HI20:
7280 case R_NDS32_PLTREL_LO12:
7281 case R_NDS32_PLT_GOTREL_HI20:
7282 case R_NDS32_PLT_GOTREL_LO12:
7283 case R_NDS32_PLT_GOTREL_LO15:
7284 case R_NDS32_PLT_GOTREL_LO19:
7285 case R_NDS32_PLT_GOTREL_LO20:
7286
7287 /* This symbol requires a procedure linkage table entry. We
7288 actually build the entry in adjust_dynamic_symbol,
7289 because this might be a case of linking PIC code without
7290 linking in any dynamic objects, in which case we don't
7291 need to generate a procedure linkage table after all. */
7292
7293 /* If this is a local symbol, we resolve it directly without
7294 creating a procedure linkage table entry. */
7295 if (h == NULL)
7296 continue;
7297
7298 if (h->forced_local
7299 || (bfd_link_pie (info) && h->def_regular))
7300 break;
7301
7302 elf32_nds32_hash_entry (h)->tls_type = GOT_NORMAL;
7303 h->needs_plt = 1;
7304 h->plt.refcount += 1;
7305 break;
7306
7307 case R_NDS32_16_RELA:
7308 case R_NDS32_20_RELA:
7309 case R_NDS32_5_RELA:
7310 case R_NDS32_32_RELA:
7311 case R_NDS32_HI20_RELA:
7312 case R_NDS32_LO12S3_RELA:
7313 case R_NDS32_LO12S2_RELA:
7314 case R_NDS32_LO12S2_DP_RELA:
7315 case R_NDS32_LO12S2_SP_RELA:
7316 case R_NDS32_LO12S1_RELA:
7317 case R_NDS32_LO12S0_RELA:
7318 case R_NDS32_LO12S0_ORI_RELA:
7319 case R_NDS32_SDA16S3_RELA:
7320 case R_NDS32_SDA17S2_RELA:
7321 case R_NDS32_SDA18S1_RELA:
7322 case R_NDS32_SDA19S0_RELA:
7323 case R_NDS32_SDA15S3_RELA:
7324 case R_NDS32_SDA15S2_RELA:
7325 case R_NDS32_SDA12S2_DP_RELA:
7326 case R_NDS32_SDA12S2_SP_RELA:
7327 case R_NDS32_SDA15S1_RELA:
7328 case R_NDS32_SDA15S0_RELA:
7329 case R_NDS32_SDA_FP7U2_RELA:
7330 case R_NDS32_15_PCREL_RELA:
7331 case R_NDS32_17_PCREL_RELA:
7332 case R_NDS32_25_PCREL_RELA:
7333
7334 if (h != NULL && !bfd_link_pic (info))
7335 {
7336 h->non_got_ref = 1;
7337 h->plt.refcount += 1;
7338 }
7339
7340 /* If we are creating a shared library, and this is a reloc against
7341 a global symbol, or a non PC relative reloc against a local
7342 symbol, then we need to copy the reloc into the shared library.
7343 However, if we are linking with -Bsymbolic, we do not need to
7344 copy a reloc against a global symbol which is defined in an
7345 object we are including in the link (i.e., DEF_REGULAR is set).
7346 At this point we have not seen all the input files, so it is
7347 possible that DEF_REGULAR is not set now but will be set later
7348 (it is never cleared). We account for that possibility below by
7349 storing information in the dyn_relocs field of the hash table
7350 entry. A similar situation occurs when creating shared libraries
7351 and symbol visibility changes render the symbol local.
7352
7353 If on the other hand, we are creating an executable, we may need
7354 to keep relocations for symbols satisfied by a dynamic library
7355 if we manage to avoid copy relocs for the symbol. */
7356 if ((bfd_link_pic (info)
7357 && (sec->flags & SEC_ALLOC) != 0
7358 && ((r_type != R_NDS32_25_PCREL_RELA
7359 && r_type != R_NDS32_15_PCREL_RELA
7360 && r_type != R_NDS32_17_PCREL_RELA
7361 && !(r_type == R_NDS32_32_RELA
7362 && strcmp (sec->name, ".eh_frame") == 0))
7363 || (h != NULL
7364 && (!info->symbolic
7365 || h->root.type == bfd_link_hash_defweak
7366 || !h->def_regular))))
7367 || (!bfd_link_pic (info)
7368 && (sec->flags & SEC_ALLOC) != 0
7369 && h != NULL
7370 && (h->root.type == bfd_link_hash_defweak
7371 || !h->def_regular)))
7372 {
7373 struct elf_dyn_relocs *p;
7374 struct elf_dyn_relocs **head;
7375
7376 if (dynobj == NULL)
7377 htab->root.dynobj = dynobj = abfd;
7378
7379 /* When creating a shared object, we must copy these
7380 relocs into the output file. We create a reloc
7381 section in dynobj and make room for the reloc. */
7382 if (sreloc == NULL)
7383 {
7384 const char *name;
7385
7386 name = bfd_elf_string_from_elf_section
7387 (abfd, elf_elfheader (abfd)->e_shstrndx,
7388 elf_section_data (sec)->rela.hdr->sh_name);
7389 if (name == NULL)
7390 return FALSE;
7391
7392 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
7393 && strcmp (bfd_get_section_name (abfd, sec),
7394 name + 5) == 0);
7395
7396 sreloc = bfd_get_section_by_name (dynobj, name);
7397 if (sreloc == NULL)
7398 {
7399 flagword flags;
7400
7401 sreloc = bfd_make_section (dynobj, name);
7402 flags = (SEC_HAS_CONTENTS | SEC_READONLY
7403 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
7404 if ((sec->flags & SEC_ALLOC) != 0)
7405 flags |= SEC_ALLOC | SEC_LOAD;
7406 if (sreloc == NULL
7407 || !bfd_set_section_flags (dynobj, sreloc, flags)
7408 || !bfd_set_section_alignment (dynobj, sreloc, 2))
7409 return FALSE;
7410
7411 elf_section_type (sreloc) = SHT_RELA;
7412 }
7413 elf_section_data (sec)->sreloc = sreloc;
7414 }
7415
7416 /* If this is a global symbol, we count the number of
7417 relocations we need for this symbol. */
7418 if (h != NULL)
7419 head = &((struct elf_nds32_link_hash_entry *) h)->dyn_relocs;
7420 else
7421 {
7422 asection *s;
7423 void *vpp;
7424
7425 Elf_Internal_Sym *isym;
7426 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx);
7427 if (isym == NULL)
7428 return FALSE;
7429
7430 /* Track dynamic relocs needed for local syms too. */
7431 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
7432 if (s == NULL)
7433 return FALSE;
7434
7435 vpp = &elf_section_data (s)->local_dynrel;
7436 head = (struct elf_dyn_relocs **) vpp;
7437 }
7438
7439 p = *head;
7440 if (p == NULL || p->sec != sec)
7441 {
7442 bfd_size_type amt = sizeof (*p);
7443 p = (struct elf_dyn_relocs *) bfd_alloc (dynobj, amt);
7444 if (p == NULL)
7445 return FALSE;
7446 p->next = *head;
7447 *head = p;
7448 p->sec = sec;
7449 p->count = 0;
7450 p->pc_count = 0;
7451 }
7452
7453 p->count += 1;
7454
7455 /* Since eh_frame is readonly, R_NDS32_32_RELA
7456 reloc for eh_frame will cause shared library has
7457 TEXTREL entry in the dynamic section. This lead glibc
7458 testsuites to failure (bug-13092) and cause kernel fail
7459 (bug-11819). I think the best solution is to replace
7460 absolute reloc with pc relative reloc in the eh_frame.
7461 To do that, we need to support the following issues:
7462
7463 === For GCC ===
7464 * gcc/config/nds32/nds32.h: Define
7465 ASM_PREFERRED_EH_DATA_FORMAT to encode DW_EH_PE_pcrel
7466 and DW_EH_PE_sdata4 into DWARF exception header when
7467 option have '-fpic'.
7468
7469 === For binutils ===
7470 * bfd/: Define new reloc R_NDS32_32_PCREL_RELA.
7471 * gas/config/tc-nds32.h: Define DIFF_EXPR_OK. This
7472 may break our nds DIFF mechanism, therefore, we
7473 must disable all linker relaxations to ensure
7474 correctness.
7475 * gas/config/tc-nds32.c (nds32_apply_fix): Replace
7476 R_NDS32_32_RELA with R_NDS32_32_PCREL_RELA, and
7477 do the necessary modification.
7478
7479 Unfortunately, it still have some problems for nds32
7480 to support pc relative reloc in the eh_frame. So I use
7481 another solution to fix this issue.
7482
7483 However, I find that ld always emit TEXTREL marker for
7484 R_NDS32_NONE relocs in rel.dyn. These none relocs are
7485 correspond to R_NDS32_32_RELA for .eh_frame section.
7486 It means that we always reserve redundant entries of rel.dyn
7487 for these relocs which actually do nothing in dynamic linker.
7488
7489 Therefore, we regard these relocs as pc relative relocs
7490 here and increase the pc_count. */
7491 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA
7492 || ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
7493 || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA
7494 || (r_type == R_NDS32_32_RELA
7495 && strcmp (sec->name, ".eh_frame") == 0))
7496 p->pc_count += 1;
7497 }
7498 break;
7499
7500 /* This relocation describes the C++ object vtable hierarchy.
7501 Reconstruct it for later use during GC. */
7502 case R_NDS32_RELA_GNU_VTINHERIT:
7503 case R_NDS32_GNU_VTINHERIT:
7504 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
7505 return FALSE;
7506 break;
7507
7508 /* This relocation describes which C++ vtable entries are actually
7509 used. Record for later use during GC. */
7510 case R_NDS32_GNU_VTENTRY:
7511 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
7512 return FALSE;
7513 break;
7514 case R_NDS32_RELA_GNU_VTENTRY:
7515 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
7516 return FALSE;
7517 break;
7518 }
7519 }
7520
7521 return TRUE;
7522 }
7523
7524 /* Write VAL in uleb128 format to P, returning a pointer to the
7525 following byte.
7526 This code is copied from elf-attr.c. */
7527
7528 static bfd_byte *
7529 write_uleb128 (bfd_byte *p, unsigned int val)
7530 {
7531 bfd_byte c;
7532 do
7533 {
7534 c = val & 0x7f;
7535 val >>= 7;
7536 if (val)
7537 c |= 0x80;
7538 *(p++) = c;
7539 }
7540 while (val);
7541 return p;
7542 }
7543
7544 static bfd_signed_vma
7545 calculate_offset (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
7546 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr)
7547 {
7548 bfd_signed_vma foff;
7549 bfd_vma symval, addend;
7550 asection *sym_sec;
7551
7552 /* Get the value of the symbol referred to by the reloc. */
7553 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
7554 {
7555 Elf_Internal_Sym *isym;
7556
7557 /* A local symbol. */
7558 isym = isymbuf + ELF32_R_SYM (irel->r_info);
7559
7560 if (isym->st_shndx == SHN_UNDEF)
7561 sym_sec = bfd_und_section_ptr;
7562 else if (isym->st_shndx == SHN_ABS)
7563 sym_sec = bfd_abs_section_ptr;
7564 else if (isym->st_shndx == SHN_COMMON)
7565 sym_sec = bfd_com_section_ptr;
7566 else
7567 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
7568 symval = isym->st_value + sym_sec->output_section->vma
7569 + sym_sec->output_offset;
7570 }
7571 else
7572 {
7573 unsigned long indx;
7574 struct elf_link_hash_entry *h;
7575
7576 /* An external symbol. */
7577 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
7578 h = elf_sym_hashes (abfd)[indx];
7579 BFD_ASSERT (h != NULL);
7580
7581 if (h->root.type != bfd_link_hash_defined
7582 && h->root.type != bfd_link_hash_defweak)
7583 /* This appears to be a reference to an undefined
7584 symbol. Just ignore it--it will be caught by the
7585 regular reloc processing. */
7586 return 0;
7587
7588 if (h->root.u.def.section->flags & SEC_MERGE)
7589 {
7590 sym_sec = h->root.u.def.section;
7591 symval = _bfd_merged_section_offset (abfd, &sym_sec,
7592 elf_section_data (sym_sec)->sec_info,
7593 h->root.u.def.value);
7594 symval = symval + sym_sec->output_section->vma
7595 + sym_sec->output_offset;
7596 }
7597 else
7598 symval = (h->root.u.def.value
7599 + h->root.u.def.section->output_section->vma
7600 + h->root.u.def.section->output_offset);
7601 }
7602
7603 addend = irel->r_addend;
7604
7605 foff = (symval + addend
7606 - (irel->r_offset + sec->output_section->vma + sec->output_offset));
7607 return foff;
7608 }
7609 \f
7610
7611 /* Convert a 32-bit instruction to 16-bit one.
7612 INSN is the input 32-bit instruction, INSN16 is the output 16-bit
7613 instruction. If INSN_TYPE is not NULL, it the CGEN instruction
7614 type of INSN16. Return 1 if successful. */
7615
7616 static int
7617 nds32_convert_32_to_16_alu1 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7618 int *pinsn_type)
7619 {
7620 uint16_t insn16 = 0;
7621 int insn_type = 0;
7622 unsigned long mach = bfd_get_mach (abfd);
7623
7624 if (N32_SH5 (insn) != 0)
7625 return 0;
7626
7627 switch (N32_SUB5 (insn))
7628 {
7629 case N32_ALU1_ADD_SLLI:
7630 case N32_ALU1_ADD_SRLI:
7631 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
7632 {
7633 insn16 = N16_TYPE333 (ADD333, N32_RT5 (insn), N32_RA5 (insn),
7634 N32_RB5 (insn));
7635 insn_type = NDS32_INSN_ADD333;
7636 }
7637 else if (N32_IS_RT4 (insn))
7638 {
7639 if (N32_RT5 (insn) == N32_RA5 (insn))
7640 insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RB5 (insn));
7641 else if (N32_RT5 (insn) == N32_RB5 (insn))
7642 insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RA5 (insn));
7643 insn_type = NDS32_INSN_ADD45;
7644 }
7645 break;
7646
7647 case N32_ALU1_SUB_SLLI:
7648 case N32_ALU1_SUB_SRLI:
7649 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
7650 {
7651 insn16 = N16_TYPE333 (SUB333, N32_RT5 (insn), N32_RA5 (insn),
7652 N32_RB5 (insn));
7653 insn_type = NDS32_INSN_SUB333;
7654 }
7655 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
7656 {
7657 insn16 = N16_TYPE45 (SUB45, N32_RT54 (insn), N32_RB5 (insn));
7658 insn_type = NDS32_INSN_SUB45;
7659 }
7660 break;
7661
7662 case N32_ALU1_AND_SLLI:
7663 case N32_ALU1_AND_SRLI:
7664 /* and $rt, $rt, $rb -> and33 for v3, v3m. */
7665 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7666 && N32_IS_RB3 (insn))
7667 {
7668 if (N32_RT5 (insn) == N32_RA5 (insn))
7669 insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RB5 (insn));
7670 else if (N32_RT5 (insn) == N32_RB5 (insn))
7671 insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RA5 (insn));
7672 if (insn16)
7673 insn_type = NDS32_INSN_AND33;
7674 }
7675 break;
7676
7677 case N32_ALU1_XOR_SLLI:
7678 case N32_ALU1_XOR_SRLI:
7679 /* xor $rt, $rt, $rb -> xor33 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 (XOR33, N32_RT5 (insn), N32_RB5 (insn));
7685 else if (N32_RT5 (insn) == N32_RB5 (insn))
7686 insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RA5 (insn));
7687 if (insn16)
7688 insn_type = NDS32_INSN_XOR33;
7689 }
7690 break;
7691
7692 case N32_ALU1_OR_SLLI:
7693 case N32_ALU1_OR_SRLI:
7694 /* or $rt, $rt, $rb -> or33 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 (OR33, N32_RT5 (insn), N32_RB5 (insn));
7700 else if (N32_RT5 (insn) == N32_RB5 (insn))
7701 insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RA5 (insn));
7702 if (insn16)
7703 insn_type = NDS32_INSN_OR33;
7704 }
7705 break;
7706 case N32_ALU1_NOR:
7707 /* nor $rt, $ra, $ra -> not33 for v3, v3m. */
7708 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RB3 (insn)
7709 && N32_RA5 (insn) == N32_RB5 (insn))
7710 {
7711 insn16 = N16_MISC33 (NOT33, N32_RT5 (insn), N32_RA5 (insn));
7712 insn_type = NDS32_INSN_NOT33;
7713 }
7714 break;
7715 case N32_ALU1_SRAI:
7716 if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
7717 {
7718 insn16 = N16_TYPE45 (SRAI45, N32_RT54 (insn), N32_UB5 (insn));
7719 insn_type = NDS32_INSN_SRAI45;
7720 }
7721 break;
7722
7723 case N32_ALU1_SRLI:
7724 if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
7725 {
7726 insn16 = N16_TYPE45 (SRLI45, N32_RT54 (insn), N32_UB5 (insn));
7727 insn_type = NDS32_INSN_SRLI45;
7728 }
7729 break;
7730
7731 case N32_ALU1_SLLI:
7732 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_UB5 (insn) < 8)
7733 {
7734 insn16 = N16_TYPE333 (SLLI333, N32_RT5 (insn), N32_RA5 (insn),
7735 N32_UB5 (insn));
7736 insn_type = NDS32_INSN_SLLI333;
7737 }
7738 break;
7739
7740 case N32_ALU1_ZEH:
7741 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7742 {
7743 insn16 = N16_BFMI333 (ZEH33, N32_RT5 (insn), N32_RA5 (insn));
7744 insn_type = NDS32_INSN_ZEH33;
7745 }
7746 break;
7747
7748 case N32_ALU1_SEB:
7749 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7750 {
7751 insn16 = N16_BFMI333 (SEB33, N32_RT5 (insn), N32_RA5 (insn));
7752 insn_type = NDS32_INSN_SEB33;
7753 }
7754 break;
7755
7756 case N32_ALU1_SEH:
7757 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7758 {
7759 insn16 = N16_BFMI333 (SEH33, N32_RT5 (insn), N32_RA5 (insn));
7760 insn_type = NDS32_INSN_SEH33;
7761 }
7762 break;
7763
7764 case N32_ALU1_SLT:
7765 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7766 {
7767 /* Implicit r15. */
7768 insn16 = N16_TYPE45 (SLT45, N32_RA54 (insn), N32_RB5 (insn));
7769 insn_type = NDS32_INSN_SLT45;
7770 }
7771 break;
7772
7773 case N32_ALU1_SLTS:
7774 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7775 {
7776 /* Implicit r15. */
7777 insn16 = N16_TYPE45 (SLTS45, N32_RA54 (insn), N32_RB5 (insn));
7778 insn_type = NDS32_INSN_SLTS45;
7779 }
7780 break;
7781 }
7782
7783 if ((insn16 & 0x8000) == 0)
7784 return 0;
7785
7786 if (pinsn16)
7787 *pinsn16 = insn16;
7788 if (pinsn_type)
7789 *pinsn_type = insn_type;
7790 return 1;
7791 }
7792
7793 static int
7794 nds32_convert_32_to_16_alu2 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7795 int *pinsn_type)
7796 {
7797 uint16_t insn16 = 0;
7798 int insn_type;
7799 unsigned long mach = bfd_get_mach (abfd);
7800
7801 /* TODO: bset, bclr, btgl, btst. */
7802 if (__GF (insn, 6, 4) != 0)
7803 return 0;
7804
7805 switch (N32_IMMU (insn, 6))
7806 {
7807 case N32_ALU2_MUL:
7808 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7809 && N32_IS_RB3 (insn))
7810 {
7811 if (N32_RT5 (insn) == N32_RA5 (insn))
7812 insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RB5 (insn));
7813 else if (N32_RT5 (insn) == N32_RB5 (insn))
7814 insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RA5 (insn));
7815 if (insn16)
7816 insn_type = NDS32_INSN_MUL33;
7817 }
7818 }
7819
7820 if ((insn16 & 0x8000) == 0)
7821 return 0;
7822
7823 if (pinsn16)
7824 *pinsn16 = insn16;
7825 if (pinsn_type)
7826 *pinsn_type = insn_type;
7827 return 1;
7828 }
7829
7830 int
7831 nds32_convert_32_to_16 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7832 int *pinsn_type)
7833 {
7834 int op6;
7835 uint16_t insn16 = 0;
7836 int insn_type = 0;
7837 unsigned long mach = bfd_get_mach (abfd);
7838
7839 /* Decode 32-bit instruction. */
7840 if (insn & 0x80000000)
7841 {
7842 /* Not 32-bit insn. */
7843 return 0;
7844 }
7845
7846 op6 = N32_OP6 (insn);
7847
7848 /* Convert it to 16-bit instruction. */
7849 switch (op6)
7850 {
7851 case N32_OP6_MOVI:
7852 if (IS_WITHIN_S (N32_IMM20S (insn), 5))
7853 {
7854 insn16 = N16_TYPE55 (MOVI55, N32_RT5 (insn), N32_IMM20S (insn));
7855 insn_type = NDS32_INSN_MOVI55;
7856 }
7857 else if (mach >= MACH_V3 && N32_IMM20S (insn) >= 16
7858 && N32_IMM20S (insn) < 48 && N32_IS_RT4 (insn))
7859 {
7860 insn16 = N16_TYPE45 (MOVPI45, N32_RT54 (insn),
7861 N32_IMM20S (insn) - 16);
7862 insn_type = NDS32_INSN_MOVPI45;
7863 }
7864 break;
7865
7866 case N32_OP6_ADDI:
7867 if (N32_IMM15S (insn) == 0)
7868 {
7869 /* Do not convert `addi $sp, $sp, 0' to `mov55 $sp, $sp',
7870 because `mov55 $sp, $sp' is ifret16 in V3 ISA. */
7871 if (mach <= MACH_V2
7872 || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7873 {
7874 insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7875 insn_type = NDS32_INSN_MOV55;
7876 }
7877 }
7878 else if (N32_IMM15S (insn) > 0)
7879 {
7880 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) < 8)
7881 {
7882 insn16 = N16_TYPE333 (ADDI333, N32_RT5 (insn), N32_RA5 (insn),
7883 N32_IMM15S (insn));
7884 insn_type = NDS32_INSN_ADDI333;
7885 }
7886 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7887 && N32_IMM15S (insn) < 32)
7888 {
7889 insn16 = N16_TYPE45 (ADDI45, N32_RT54 (insn), N32_IMM15S (insn));
7890 insn_type = NDS32_INSN_ADDI45;
7891 }
7892 else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7893 && N32_RT5 (insn) == N32_RA5 (insn)
7894 && N32_IMM15S (insn) < 512)
7895 {
7896 insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7897 insn_type = NDS32_INSN_ADDI10_SP;
7898 }
7899 else if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7900 && N32_RA5 (insn) == REG_SP && N32_IMM15S (insn) < 256
7901 && (N32_IMM15S (insn) % 4 == 0))
7902 {
7903 insn16 = N16_TYPE36 (ADDRI36_SP, N32_RT5 (insn),
7904 N32_IMM15S (insn) >> 2);
7905 insn_type = NDS32_INSN_ADDRI36_SP;
7906 }
7907 }
7908 else
7909 {
7910 /* Less than 0. */
7911 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) > -8)
7912 {
7913 insn16 = N16_TYPE333 (SUBI333, N32_RT5 (insn), N32_RA5 (insn),
7914 0 - N32_IMM15S (insn));
7915 insn_type = NDS32_INSN_SUBI333;
7916 }
7917 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7918 && N32_IMM15S (insn) > -32)
7919 {
7920 insn16 = N16_TYPE45 (SUBI45, N32_RT54 (insn),
7921 0 - N32_IMM15S (insn));
7922 insn_type = NDS32_INSN_SUBI45;
7923 }
7924 else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7925 && N32_RT5 (insn) == N32_RA5 (insn)
7926 && N32_IMM15S (insn) >= -512)
7927 {
7928 insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7929 insn_type = NDS32_INSN_ADDI10_SP;
7930 }
7931 }
7932 break;
7933
7934 case N32_OP6_ORI:
7935 if (N32_IMM15S (insn) == 0)
7936 {
7937 /* Do not convert `ori $sp, $sp, 0' to `mov55 $sp, $sp',
7938 because `mov55 $sp, $sp' is ifret16 in V3 ISA. */
7939 if (mach <= MACH_V2
7940 || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7941 {
7942 insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7943 insn_type = NDS32_INSN_MOV55;
7944 }
7945 }
7946 break;
7947
7948 case N32_OP6_SUBRI:
7949 if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7950 && N32_IS_RA3 (insn) && N32_IMM15S (insn) == 0)
7951 {
7952 insn16 = N16_MISC33 (NEG33, N32_RT5 (insn), N32_RA5 (insn));
7953 insn_type = NDS32_INSN_NEG33;
7954 }
7955 break;
7956
7957 case N32_OP6_ANDI:
7958 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7959 {
7960 if (N32_IMM15U (insn) == 1)
7961 {
7962 insn16 = N16_BFMI333 (XLSB33, N32_RT5 (insn), N32_RA5 (insn));
7963 insn_type = NDS32_INSN_XLSB33;
7964 }
7965 else if (N32_IMM15U (insn) == 0x7ff)
7966 {
7967 insn16 = N16_BFMI333 (X11B33, N32_RT5 (insn), N32_RA5 (insn));
7968 insn_type = NDS32_INSN_X11B33;
7969 }
7970 else if (N32_IMM15U (insn) == 0xff)
7971 {
7972 insn16 = N16_BFMI333 (ZEB33, N32_RT5 (insn), N32_RA5 (insn));
7973 insn_type = NDS32_INSN_ZEB33;
7974 }
7975 else if (mach >= MACH_V3 && N32_RT5 (insn) == N32_RA5 (insn)
7976 && N32_IMM15U (insn) < 256)
7977 {
7978 int imm15u = N32_IMM15U (insn);
7979
7980 if (__builtin_popcount (imm15u) == 1)
7981 {
7982 /* BMSKI33 */
7983 int imm3u = __builtin_ctz (imm15u);
7984
7985 insn16 = N16_BFMI333 (BMSKI33, N32_RT5 (insn), imm3u);
7986 insn_type = NDS32_INSN_BMSKI33;
7987 }
7988 else if (imm15u != 0 && __builtin_popcount (imm15u + 1) == 1)
7989 {
7990 /* FEXTI33 */
7991 int imm3u = __builtin_ctz (imm15u + 1) - 1;
7992
7993 insn16 = N16_BFMI333 (FEXTI33, N32_RT5 (insn), imm3u);
7994 insn_type = NDS32_INSN_FEXTI33;
7995 }
7996 }
7997 }
7998 break;
7999
8000 case N32_OP6_SLTI:
8001 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
8002 && IS_WITHIN_U (N32_IMM15S (insn), 5))
8003 {
8004 insn16 = N16_TYPE45 (SLTI45, N32_RA54 (insn), N32_IMM15S (insn));
8005 insn_type = NDS32_INSN_SLTI45;
8006 }
8007 break;
8008
8009 case N32_OP6_SLTSI:
8010 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
8011 && IS_WITHIN_U (N32_IMM15S (insn), 5))
8012 {
8013 insn16 = N16_TYPE45 (SLTSI45, N32_RA54 (insn), N32_IMM15S (insn));
8014 insn_type = NDS32_INSN_SLTSI45;
8015 }
8016 break;
8017
8018 case N32_OP6_LWI:
8019 if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
8020 {
8021 insn16 = N16_TYPE45 (LWI450, N32_RT54 (insn), N32_RA5 (insn));
8022 insn_type = NDS32_INSN_LWI450;
8023 }
8024 else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8025 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8026 {
8027 insn16 = N16_TYPE333 (LWI333, N32_RT5 (insn), N32_RA5 (insn),
8028 N32_IMM15S (insn));
8029 insn_type = NDS32_INSN_LWI333;
8030 }
8031 else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
8032 && IS_WITHIN_U (N32_IMM15S (insn), 7))
8033 {
8034 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
8035 insn_type = NDS32_INSN_LWI37;
8036 }
8037 else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
8038 && IS_WITHIN_U (N32_IMM15S (insn), 7))
8039 {
8040 insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 0, N32_IMM15S (insn));
8041 insn_type = NDS32_INSN_LWI37_SP;
8042 }
8043 else if (mach >= MACH_V2 && N32_IS_RT4 (insn) && N32_RA5 (insn) == REG_R8
8044 && -32 <= N32_IMM15S (insn) && N32_IMM15S (insn) < 0)
8045 {
8046 insn16 = N16_TYPE45 (LWI45_FE, N32_RT54 (insn),
8047 N32_IMM15S (insn) + 32);
8048 insn_type = NDS32_INSN_LWI45_FE;
8049 }
8050 break;
8051
8052 case N32_OP6_SWI:
8053 if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
8054 {
8055 insn16 = N16_TYPE45 (SWI450, N32_RT54 (insn), N32_RA5 (insn));
8056 insn_type = NDS32_INSN_SWI450;
8057 }
8058 else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8059 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8060 {
8061 insn16 = N16_TYPE333 (SWI333, N32_RT5 (insn), N32_RA5 (insn),
8062 N32_IMM15S (insn));
8063 insn_type = NDS32_INSN_SWI333;
8064 }
8065 else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
8066 && IS_WITHIN_U (N32_IMM15S (insn), 7))
8067 {
8068 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
8069 insn_type = NDS32_INSN_SWI37;
8070 }
8071 else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
8072 && IS_WITHIN_U (N32_IMM15S (insn), 7))
8073 {
8074 insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 1, N32_IMM15S (insn));
8075 insn_type = NDS32_INSN_SWI37_SP;
8076 }
8077 break;
8078
8079 case N32_OP6_LWI_BI:
8080 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8081 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8082 {
8083 insn16 = N16_TYPE333 (LWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
8084 N32_IMM15S (insn));
8085 insn_type = NDS32_INSN_LWI333_BI;
8086 }
8087 break;
8088
8089 case N32_OP6_SWI_BI:
8090 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8091 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8092 {
8093 insn16 = N16_TYPE333 (SWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
8094 N32_IMM15S (insn));
8095 insn_type = NDS32_INSN_SWI333_BI;
8096 }
8097 break;
8098
8099 case N32_OP6_LHI:
8100 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8101 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8102 {
8103 insn16 = N16_TYPE333 (LHI333, N32_RT5 (insn), N32_RA5 (insn),
8104 N32_IMM15S (insn));
8105 insn_type = NDS32_INSN_LHI333;
8106 }
8107 break;
8108
8109 case N32_OP6_SHI:
8110 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8111 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8112 {
8113 insn16 = N16_TYPE333 (SHI333, N32_RT5 (insn), N32_RA5 (insn),
8114 N32_IMM15S (insn));
8115 insn_type = NDS32_INSN_SHI333;
8116 }
8117 break;
8118
8119 case N32_OP6_LBI:
8120 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8121 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8122 {
8123 insn16 = N16_TYPE333 (LBI333, N32_RT5 (insn), N32_RA5 (insn),
8124 N32_IMM15S (insn));
8125 insn_type = NDS32_INSN_LBI333;
8126 }
8127 break;
8128
8129 case N32_OP6_SBI:
8130 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
8131 && IS_WITHIN_U (N32_IMM15S (insn), 3))
8132 {
8133 insn16 = N16_TYPE333 (SBI333, N32_RT5 (insn), N32_RA5 (insn),
8134 N32_IMM15S (insn));
8135 insn_type = NDS32_INSN_SBI333;
8136 }
8137 break;
8138
8139 case N32_OP6_ALU1:
8140 return nds32_convert_32_to_16_alu1 (abfd, insn, pinsn16, pinsn_type);
8141
8142 case N32_OP6_ALU2:
8143 return nds32_convert_32_to_16_alu2 (abfd, insn, pinsn16, pinsn_type);
8144
8145 case N32_OP6_BR1:
8146 if (!IS_WITHIN_S (N32_IMM14S (insn), 8))
8147 goto done;
8148
8149 if ((insn & N32_BIT (14)) == 0)
8150 {
8151 /* N32_BR1_BEQ */
8152 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
8153 && N32_RT5 (insn) != REG_R5)
8154 insn16 = N16_TYPE38 (BEQS38, N32_RT5 (insn), N32_IMM14S (insn));
8155 else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
8156 && N32_RA5 (insn) != REG_R5)
8157 insn16 = N16_TYPE38 (BEQS38, N32_RA5 (insn), N32_IMM14S (insn));
8158 insn_type = NDS32_INSN_BEQS38;
8159 break;
8160 }
8161 else
8162 {
8163 /* N32_BR1_BNE */
8164 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
8165 && N32_RT5 (insn) != REG_R5)
8166 insn16 = N16_TYPE38 (BNES38, N32_RT5 (insn), N32_IMM14S (insn));
8167 else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
8168 && N32_RA5 (insn) != REG_R5)
8169 insn16 = N16_TYPE38 (BNES38, N32_RA5 (insn), N32_IMM14S (insn));
8170 insn_type = NDS32_INSN_BNES38;
8171 break;
8172 }
8173 break;
8174
8175 case N32_OP6_BR2:
8176 switch (N32_BR2_SUB (insn))
8177 {
8178 case N32_BR2_BEQZ:
8179 if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
8180 {
8181 insn16 = N16_TYPE38 (BEQZ38, N32_RT5 (insn), N32_IMM16S (insn));
8182 insn_type = NDS32_INSN_BEQZ38;
8183 }
8184 else if (N32_RT5 (insn) == REG_R15
8185 && IS_WITHIN_S (N32_IMM16S (insn), 8))
8186 {
8187 insn16 = N16_TYPE8 (BEQZS8, N32_IMM16S (insn));
8188 insn_type = NDS32_INSN_BEQZS8;
8189 }
8190 break;
8191
8192 case N32_BR2_BNEZ:
8193 if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
8194 {
8195 insn16 = N16_TYPE38 (BNEZ38, N32_RT5 (insn), N32_IMM16S (insn));
8196 insn_type = NDS32_INSN_BNEZ38;
8197 }
8198 else if (N32_RT5 (insn) == REG_R15
8199 && IS_WITHIN_S (N32_IMM16S (insn), 8))
8200 {
8201 insn16 = N16_TYPE8 (BNEZS8, N32_IMM16S (insn));
8202 insn_type = NDS32_INSN_BNEZS8;
8203 }
8204 break;
8205
8206 case N32_BR2_SOP0:
8207 if (__GF (insn, 20, 5) == 0 && IS_WITHIN_U (N32_IMM16S (insn), 9))
8208 {
8209 insn16 = N16_TYPE9 (IFCALL9, N32_IMM16S (insn));
8210 insn_type = NDS32_INSN_IFCALL9;
8211 }
8212 break;
8213 }
8214 break;
8215
8216 case N32_OP6_JI:
8217 if ((insn & N32_BIT (24)) == 0)
8218 {
8219 /* N32_JI_J */
8220 if (IS_WITHIN_S (N32_IMM24S (insn), 8))
8221 {
8222 insn16 = N16_TYPE8 (J8, N32_IMM24S (insn));
8223 insn_type = NDS32_INSN_J8;
8224 }
8225 }
8226 break;
8227
8228 case N32_OP6_JREG:
8229 if (__GF (insn, 8, 2) != 0)
8230 goto done;
8231
8232 switch (N32_IMMU (insn, 5))
8233 {
8234 case N32_JREG_JR:
8235 if (N32_JREG_HINT (insn) == 0)
8236 {
8237 /* jr */
8238 insn16 = N16_TYPE5 (JR5, N32_RB5 (insn));
8239 insn_type = NDS32_INSN_JR5;
8240 }
8241 else if (N32_JREG_HINT (insn) == 1)
8242 {
8243 /* ret */
8244 insn16 = N16_TYPE5 (RET5, N32_RB5 (insn));
8245 insn_type = NDS32_INSN_RET5;
8246 }
8247 else if (N32_JREG_HINT (insn) == 3)
8248 {
8249 /* ifret = mov55 $sp, $sp */
8250 insn16 = N16_TYPE55 (MOV55, REG_SP, REG_SP);
8251 insn_type = NDS32_INSN_IFRET;
8252 }
8253 break;
8254
8255 case N32_JREG_JRAL:
8256 /* It's convertible when return rt5 is $lp and address
8257 translation is kept. */
8258 if (N32_RT5 (insn) == REG_LP && N32_JREG_HINT (insn) == 0)
8259 {
8260 insn16 = N16_TYPE5 (JRAL5, N32_RB5 (insn));
8261 insn_type = NDS32_INSN_JRAL5;
8262 }
8263 break;
8264 }
8265 break;
8266
8267 case N32_OP6_MISC:
8268 if (N32_SUB5 (insn) == N32_MISC_BREAK && N32_SWID (insn) < 32)
8269 {
8270 /* For v3, swid above 31 are used for ex9.it. */
8271 insn16 = N16_TYPE5 (BREAK16, N32_SWID (insn));
8272 insn_type = NDS32_INSN_BREAK16;
8273 }
8274 break;
8275
8276 default:
8277 /* This instruction has no 16-bit variant. */
8278 goto done;
8279 }
8280
8281 done:
8282 /* Bit-15 of insn16 should be set for a valid instruction. */
8283 if ((insn16 & 0x8000) == 0)
8284 return 0;
8285
8286 if (pinsn16)
8287 *pinsn16 = insn16;
8288 if (pinsn_type)
8289 *pinsn_type = insn_type;
8290 return 1;
8291 }
8292
8293 static int
8294 special_convert_32_to_16 (unsigned long insn, uint16_t *pinsn16,
8295 Elf_Internal_Rela *reloc)
8296 {
8297 uint16_t insn16 = 0;
8298
8299 if ((reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG) == 0
8300 || (ELF32_R_TYPE (reloc->r_info) != R_NDS32_INSN16))
8301 return 0;
8302
8303 if (!N32_IS_RT3 (insn))
8304 return 0;
8305
8306 switch (N32_OP6 (insn))
8307 {
8308 case N32_OP6_LWI:
8309 if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
8310 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
8311 break;
8312 case N32_OP6_SWI:
8313 if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
8314 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
8315 break;
8316 case N32_OP6_HWGP:
8317 if (!IS_WITHIN_U (N32_IMM17S (insn), 7))
8318 break;
8319
8320 if (__GF (insn, 17, 3) == 6)
8321 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM17S (insn));
8322 else if (__GF (insn, 17, 3) == 7)
8323 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM17S (insn));
8324 break;
8325 }
8326
8327 if ((insn16 & 0x8000) == 0)
8328 return 0;
8329
8330 *pinsn16 = insn16;
8331 return 1;
8332 }
8333
8334 /* Convert a 16-bit instruction to 32-bit one.
8335 INSN16 it the input and PINSN it the point to output.
8336 Return non-zero on successful. Otherwise 0 is returned. */
8337
8338 int
8339 nds32_convert_16_to_32 (bfd *abfd, uint16_t insn16, uint32_t *pinsn)
8340 {
8341 uint32_t insn = 0xffffffff;
8342 unsigned long mach = bfd_get_mach (abfd);
8343
8344 /* NOTE: push25, pop25 and movd44 do not have 32-bit variants. */
8345
8346 switch (__GF (insn16, 9, 6))
8347 {
8348 case 0x4: /* add45 */
8349 insn = N32_ALU1 (ADD, N16_RT4 (insn16), N16_RT4 (insn16),
8350 N16_RA5 (insn16));
8351 goto done;
8352 case 0x5: /* sub45 */
8353 insn = N32_ALU1 (SUB, N16_RT4 (insn16), N16_RT4 (insn16),
8354 N16_RA5 (insn16));
8355 goto done;
8356 case 0x6: /* addi45 */
8357 insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
8358 N16_IMM5U (insn16));
8359 goto done;
8360 case 0x7: /* subi45 */
8361 insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
8362 -N16_IMM5U (insn16));
8363 goto done;
8364 case 0x8: /* srai45 */
8365 insn = N32_ALU1 (SRAI, N16_RT4 (insn16), N16_RT4 (insn16),
8366 N16_IMM5U (insn16));
8367 goto done;
8368 case 0x9: /* srli45 */
8369 insn = N32_ALU1 (SRLI, N16_RT4 (insn16), N16_RT4 (insn16),
8370 N16_IMM5U (insn16));
8371 goto done;
8372 case 0xa: /* slli333 */
8373 insn = N32_ALU1 (SLLI, N16_RT3 (insn16), N16_RA3 (insn16),
8374 N16_IMM3U (insn16));
8375 goto done;
8376 case 0xc: /* add333 */
8377 insn = N32_ALU1 (ADD, N16_RT3 (insn16), N16_RA3 (insn16),
8378 N16_RB3 (insn16));
8379 goto done;
8380 case 0xd: /* sub333 */
8381 insn = N32_ALU1 (SUB, N16_RT3 (insn16), N16_RA3 (insn16),
8382 N16_RB3 (insn16));
8383 goto done;
8384 case 0xe: /* addi333 */
8385 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
8386 N16_IMM3U (insn16));
8387 goto done;
8388 case 0xf: /* subi333 */
8389 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
8390 -N16_IMM3U (insn16));
8391 goto done;
8392 case 0x10: /* lwi333 */
8393 insn = N32_TYPE2 (LWI, N16_RT3 (insn16), N16_RA3 (insn16),
8394 N16_IMM3U (insn16));
8395 goto done;
8396 case 0x12: /* lhi333 */
8397 insn = N32_TYPE2 (LHI, N16_RT3 (insn16), N16_RA3 (insn16),
8398 N16_IMM3U (insn16));
8399 goto done;
8400 case 0x13: /* lbi333 */
8401 insn = N32_TYPE2 (LBI, N16_RT3 (insn16), N16_RA3 (insn16),
8402 N16_IMM3U (insn16));
8403 goto done;
8404 case 0x11: /* lwi333.bi */
8405 insn = N32_TYPE2 (LWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
8406 N16_IMM3U (insn16));
8407 goto done;
8408 case 0x14: /* swi333 */
8409 insn = N32_TYPE2 (SWI, N16_RT3 (insn16), N16_RA3 (insn16),
8410 N16_IMM3U (insn16));
8411 goto done;
8412 case 0x16: /* shi333 */
8413 insn = N32_TYPE2 (SHI, N16_RT3 (insn16), N16_RA3 (insn16),
8414 N16_IMM3U (insn16));
8415 goto done;
8416 case 0x17: /* sbi333 */
8417 insn = N32_TYPE2 (SBI, N16_RT3 (insn16), N16_RA3 (insn16),
8418 N16_IMM3U (insn16));
8419 goto done;
8420 case 0x15: /* swi333.bi */
8421 insn = N32_TYPE2 (SWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
8422 N16_IMM3U (insn16));
8423 goto done;
8424 case 0x18: /* addri36.sp */
8425 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), REG_SP,
8426 N16_IMM6U (insn16) << 2);
8427 goto done;
8428 case 0x19: /* lwi45.fe */
8429 insn = N32_TYPE2 (LWI, N16_RT4 (insn16), REG_R8,
8430 (N16_IMM5U (insn16) - 32));
8431 goto done;
8432 case 0x1a: /* lwi450 */
8433 insn = N32_TYPE2 (LWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
8434 goto done;
8435 case 0x1b: /* swi450 */
8436 insn = N32_TYPE2 (SWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
8437 goto done;
8438
8439 /* These are r15 implied instructions. */
8440 case 0x30: /* slts45 */
8441 insn = N32_ALU1 (SLTS, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
8442 goto done;
8443 case 0x31: /* slt45 */
8444 insn = N32_ALU1 (SLT, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
8445 goto done;
8446 case 0x32: /* sltsi45 */
8447 insn = N32_TYPE2 (SLTSI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
8448 goto done;
8449 case 0x33: /* slti45 */
8450 insn = N32_TYPE2 (SLTI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
8451 goto done;
8452 case 0x34: /* beqzs8, bnezs8 */
8453 if (insn16 & N32_BIT (8))
8454 insn = N32_BR2 (BNEZ, REG_TA, N16_IMM8S (insn16));
8455 else
8456 insn = N32_BR2 (BEQZ, REG_TA, N16_IMM8S (insn16));
8457 goto done;
8458
8459 case 0x35: /* break16, ex9.it */
8460 /* Only consider range of v3 break16. */
8461 insn = N32_TYPE0 (MISC, (N16_IMM5U (insn16) << 5) | N32_MISC_BREAK);
8462 goto done;
8463
8464 case 0x3c: /* ifcall9 */
8465 insn = N32_BR2 (SOP0, 0, N16_IMM9U (insn16));
8466 goto done;
8467 case 0x3d: /* movpi45 */
8468 insn = N32_TYPE1 (MOVI, N16_RT4 (insn16), N16_IMM5U (insn16) + 16);
8469 goto done;
8470
8471 case 0x3f: /* MISC33 */
8472 switch (insn16 & 0x7)
8473 {
8474 case 2: /* neg33 */
8475 insn = N32_TYPE2 (SUBRI, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8476 break;
8477 case 3: /* not33 */
8478 insn = N32_ALU1 (NOR, N16_RT3 (insn16), N16_RA3 (insn16),
8479 N16_RA3 (insn16));
8480 break;
8481 case 4: /* mul33 */
8482 insn = N32_ALU2 (MUL, N16_RT3 (insn16), N16_RT3 (insn16),
8483 N16_RA3 (insn16));
8484 break;
8485 case 5: /* xor33 */
8486 insn = N32_ALU1 (XOR, N16_RT3 (insn16), N16_RT3 (insn16),
8487 N16_RA3 (insn16));
8488 break;
8489 case 6: /* and33 */
8490 insn = N32_ALU1 (AND, N16_RT3 (insn16), N16_RT3 (insn16),
8491 N16_RA3 (insn16));
8492 break;
8493 case 7: /* or33 */
8494 insn = N32_ALU1 (OR, N16_RT3 (insn16), N16_RT3 (insn16),
8495 N16_RA3 (insn16));
8496 break;
8497 }
8498 goto done;
8499
8500 case 0xb:
8501 switch (insn16 & 0x7)
8502 {
8503 case 0: /* zeb33 */
8504 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0xff);
8505 break;
8506 case 1: /* zeh33 */
8507 insn = N32_ALU1 (ZEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8508 break;
8509 case 2: /* seb33 */
8510 insn = N32_ALU1 (SEB, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8511 break;
8512 case 3: /* seh33 */
8513 insn = N32_ALU1 (SEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
8514 break;
8515 case 4: /* xlsb33 */
8516 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 1);
8517 break;
8518 case 5: /* x11b33 */
8519 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0x7ff);
8520 break;
8521 case 6: /* bmski33 */
8522 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
8523 1 << __GF (insn16, 3, 3));
8524 break;
8525 case 7: /* fexti33 */
8526 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
8527 (1 << (__GF (insn16, 3, 3) + 1)) - 1);
8528 break;
8529 }
8530 goto done;
8531 }
8532
8533 switch (__GF (insn16, 10, 5))
8534 {
8535 case 0x0: /* mov55 or ifret16 */
8536 if (mach >= MACH_V3 && N16_RT5 (insn16) == REG_SP
8537 && N16_RT5 (insn16) == N16_RA5 (insn16))
8538 insn = N32_JREG (JR, 0, 0, 0, 3);
8539 else
8540 insn = N32_TYPE2 (ADDI, N16_RT5 (insn16), N16_RA5 (insn16), 0);
8541 goto done;
8542 case 0x1: /* movi55 */
8543 insn = N32_TYPE1 (MOVI, N16_RT5 (insn16), N16_IMM5S (insn16));
8544 goto done;
8545 case 0x1b: /* addi10s (V2) */
8546 insn = N32_TYPE2 (ADDI, REG_SP, REG_SP, N16_IMM10S (insn16));
8547 goto done;
8548 }
8549
8550 switch (__GF (insn16, 11, 4))
8551 {
8552 case 0x7: /* lwi37.fp/swi37.fp */
8553 if (insn16 & N32_BIT (7)) /* swi37.fp */
8554 insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
8555 else /* lwi37.fp */
8556 insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
8557 goto done;
8558 case 0x8: /* beqz38 */
8559 insn = N32_BR2 (BEQZ, N16_RT38 (insn16), N16_IMM8S (insn16));
8560 goto done;
8561 case 0x9: /* bnez38 */
8562 insn = N32_BR2 (BNEZ, N16_RT38 (insn16), N16_IMM8S (insn16));
8563 goto done;
8564 case 0xa: /* beqs38/j8, implied r5 */
8565 if (N16_RT38 (insn16) == 5)
8566 insn = N32_JI (J, N16_IMM8S (insn16));
8567 else
8568 insn = N32_BR1 (BEQ, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
8569 goto done;
8570 case 0xb: /* bnes38 and others. */
8571 if (N16_RT38 (insn16) == 5)
8572 {
8573 switch (__GF (insn16, 5, 3))
8574 {
8575 case 0: /* jr5 */
8576 insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 0);
8577 break;
8578 case 4: /* ret5 */
8579 insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 1);
8580 break;
8581 case 1: /* jral5 */
8582 insn = N32_JREG (JRAL, REG_LP, N16_RA5 (insn16), 0, 0);
8583 break;
8584 case 2: /* ex9.it imm5 */
8585 /* ex9.it had no 32-bit variantl. */
8586 break;
8587 case 5: /* add5.pc */
8588 /* add5.pc had no 32-bit variantl. */
8589 break;
8590 }
8591 }
8592 else /* bnes38 */
8593 insn = N32_BR1 (BNE, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
8594 goto done;
8595 case 0xe: /* lwi37/swi37 */
8596 if (insn16 & (1 << 7)) /* swi37.sp */
8597 insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
8598 else /* lwi37.sp */
8599 insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
8600 goto done;
8601 }
8602
8603 done:
8604 if (insn & 0x80000000)
8605 return 0;
8606
8607 if (pinsn)
8608 *pinsn = insn;
8609 return 1;
8610 }
8611 \f
8612
8613 static bfd_boolean
8614 is_sda_access_insn (unsigned long insn)
8615 {
8616 switch (N32_OP6 (insn))
8617 {
8618 case N32_OP6_LWI:
8619 case N32_OP6_LHI:
8620 case N32_OP6_LHSI:
8621 case N32_OP6_LBI:
8622 case N32_OP6_LBSI:
8623 case N32_OP6_SWI:
8624 case N32_OP6_SHI:
8625 case N32_OP6_SBI:
8626 case N32_OP6_LWC:
8627 case N32_OP6_LDC:
8628 case N32_OP6_SWC:
8629 case N32_OP6_SDC:
8630 return TRUE;
8631 default:
8632 ;
8633 }
8634 return FALSE;
8635 }
8636
8637 static unsigned long
8638 turn_insn_to_sda_access (uint32_t insn, bfd_signed_vma type, uint32_t *pinsn)
8639 {
8640 uint32_t oinsn = 0;
8641
8642 switch (type)
8643 {
8644 case R_NDS32_GOT_LO12:
8645 case R_NDS32_GOTOFF_LO12:
8646 case R_NDS32_PLTREL_LO12:
8647 case R_NDS32_PLT_GOTREL_LO12:
8648 case R_NDS32_LO12S0_RELA:
8649 switch (N32_OP6 (insn))
8650 {
8651 case N32_OP6_LBI:
8652 /* lbi.gp */
8653 oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
8654 break;
8655 case N32_OP6_LBSI:
8656 /* lbsi.gp */
8657 oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), N32_BIT (19));
8658 break;
8659 case N32_OP6_SBI:
8660 /* sbi.gp */
8661 oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
8662 break;
8663 case N32_OP6_ORI:
8664 /* addi.gp */
8665 oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), N32_BIT (19));
8666 break;
8667 }
8668 break;
8669
8670 case R_NDS32_LO12S1_RELA:
8671 switch (N32_OP6 (insn))
8672 {
8673 case N32_OP6_LHI:
8674 /* lhi.gp */
8675 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
8676 break;
8677 case N32_OP6_LHSI:
8678 /* lhsi.gp */
8679 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (18));
8680 break;
8681 case N32_OP6_SHI:
8682 /* shi.gp */
8683 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), N32_BIT (19));
8684 break;
8685 }
8686 break;
8687
8688 case R_NDS32_LO12S2_RELA:
8689 switch (N32_OP6 (insn))
8690 {
8691 case N32_OP6_LWI:
8692 /* lwi.gp */
8693 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
8694 break;
8695 case N32_OP6_SWI:
8696 /* swi.gp */
8697 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
8698 break;
8699 }
8700 break;
8701
8702 case R_NDS32_LO12S2_DP_RELA:
8703 case R_NDS32_LO12S2_SP_RELA:
8704 oinsn = (insn & 0x7ff07000) | (REG_GP << 15);
8705 break;
8706 }
8707
8708 if (oinsn)
8709 *pinsn = oinsn;
8710
8711 return oinsn != 0;
8712 }
8713
8714 /* Linker hasn't found the correct merge section for non-section symbol
8715 in relax time, this work is left to the function elf_link_input_bfd().
8716 So for non-section symbol, _bfd_merged_section_offset is also needed
8717 to find the correct symbol address. */
8718
8719 static bfd_vma
8720 nds32_elf_rela_local_sym (bfd *abfd, Elf_Internal_Sym *sym,
8721 asection **psec, Elf_Internal_Rela *rel)
8722 {
8723 asection *sec = *psec;
8724 bfd_vma relocation;
8725
8726 relocation = (sec->output_section->vma
8727 + sec->output_offset + sym->st_value);
8728 if ((sec->flags & SEC_MERGE) && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
8729 {
8730 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
8731 rel->r_addend =
8732 _bfd_merged_section_offset (abfd, psec,
8733 elf_section_data (sec)->sec_info,
8734 sym->st_value + rel->r_addend);
8735 else
8736 rel->r_addend =
8737 _bfd_merged_section_offset (abfd, psec,
8738 elf_section_data (sec)->sec_info,
8739 sym->st_value) + rel->r_addend;
8740
8741 if (sec != *psec)
8742 {
8743 /* If we have changed the section, and our original section is
8744 marked with SEC_EXCLUDE, it means that the original
8745 SEC_MERGE section has been completely subsumed in some
8746 other SEC_MERGE section. In this case, we need to leave
8747 some info around for --emit-relocs. */
8748 if ((sec->flags & SEC_EXCLUDE) != 0)
8749 sec->kept_section = *psec;
8750 sec = *psec;
8751 }
8752 rel->r_addend -= relocation;
8753 rel->r_addend += sec->output_section->vma + sec->output_offset;
8754 }
8755 return relocation;
8756 }
8757
8758 static bfd_vma
8759 calculate_memory_address (bfd *abfd, Elf_Internal_Rela *irel,
8760 Elf_Internal_Sym *isymbuf,
8761 Elf_Internal_Shdr *symtab_hdr)
8762 {
8763 bfd_signed_vma foff;
8764 bfd_vma symval, addend;
8765 Elf_Internal_Rela irel_fn;
8766 Elf_Internal_Sym *isym;
8767 asection *sym_sec;
8768
8769 /* Get the value of the symbol referred to by the reloc. */
8770 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
8771 {
8772 /* A local symbol. */
8773 isym = isymbuf + ELF32_R_SYM (irel->r_info);
8774
8775 if (isym->st_shndx == SHN_UNDEF)
8776 sym_sec = bfd_und_section_ptr;
8777 else if (isym->st_shndx == SHN_ABS)
8778 sym_sec = bfd_abs_section_ptr;
8779 else if (isym->st_shndx == SHN_COMMON)
8780 sym_sec = bfd_com_section_ptr;
8781 else
8782 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
8783 memcpy (&irel_fn, irel, sizeof (Elf_Internal_Rela));
8784 symval = nds32_elf_rela_local_sym (abfd, isym, &sym_sec, &irel_fn);
8785 addend = irel_fn.r_addend;
8786 }
8787 else
8788 {
8789 unsigned long indx;
8790 struct elf_link_hash_entry *h;
8791
8792 /* An external symbol. */
8793 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
8794 h = elf_sym_hashes (abfd)[indx];
8795 BFD_ASSERT (h != NULL);
8796
8797 while (h->root.type == bfd_link_hash_indirect
8798 || h->root.type == bfd_link_hash_warning)
8799 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8800
8801 if (h->root.type != bfd_link_hash_defined
8802 && h->root.type != bfd_link_hash_defweak)
8803 /* This appears to be a reference to an undefined
8804 symbol. Just ignore it--it will be caught by the
8805 regular reloc processing. */
8806 return 0;
8807
8808 if (h->root.u.def.section->flags & SEC_MERGE)
8809 {
8810 sym_sec = h->root.u.def.section;
8811 symval = _bfd_merged_section_offset (abfd, &sym_sec, elf_section_data
8812 (sym_sec)->sec_info, h->root.u.def.value);
8813 symval = symval + sym_sec->output_section->vma
8814 + sym_sec->output_offset;
8815 }
8816 else
8817 symval = (h->root.u.def.value
8818 + h->root.u.def.section->output_section->vma
8819 + h->root.u.def.section->output_offset);
8820 addend = irel->r_addend;
8821 }
8822
8823 foff = symval + addend;
8824
8825 return foff;
8826 }
8827
8828 static int
8829 is_16bit_NOP (bfd *abfd ATTRIBUTE_UNUSED,
8830 asection *sec, Elf_Internal_Rela *rel)
8831 {
8832 bfd_byte *contents;
8833 unsigned short insn16;
8834
8835 if (!(rel->r_addend & R_NDS32_INSN16_CONVERT_FLAG))
8836 return FALSE;
8837 contents = elf_section_data (sec)->this_hdr.contents;
8838 insn16 = bfd_getb16 (contents + rel->r_offset);
8839 if (insn16 == NDS32_NOP16)
8840 return TRUE;
8841 return FALSE;
8842 }
8843
8844 /* It checks whether the instruction could be converted to
8845 16-bit form and returns the converted one.
8846
8847 `internal_relocs' is supposed to be sorted. */
8848
8849 static int
8850 is_convert_32_to_16 (bfd *abfd, asection *sec,
8851 Elf_Internal_Rela *reloc,
8852 Elf_Internal_Rela *internal_relocs,
8853 Elf_Internal_Rela *irelend,
8854 uint16_t *insn16)
8855 {
8856 #define NORMAL_32_TO_16 (1 << 0)
8857 #define SPECIAL_32_TO_16 (1 << 1)
8858 bfd_byte *contents = NULL;
8859 bfd_signed_vma off;
8860 bfd_vma mem_addr;
8861 uint32_t insn = 0;
8862 Elf_Internal_Rela *pc_rel;
8863 Elf_Internal_Shdr *symtab_hdr;
8864 Elf_Internal_Sym *isymbuf = NULL;
8865 int convert_type;
8866 bfd_vma offset;
8867
8868 if (reloc->r_offset + 4 > sec->size)
8869 return FALSE;
8870
8871 offset = reloc->r_offset;
8872
8873 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
8874 return FALSE;
8875 insn = bfd_getb32 (contents + offset);
8876
8877 if (nds32_convert_32_to_16 (abfd, insn, insn16, NULL))
8878 convert_type = NORMAL_32_TO_16;
8879 else if (special_convert_32_to_16 (insn, insn16, reloc))
8880 convert_type = SPECIAL_32_TO_16;
8881 else
8882 return FALSE;
8883
8884 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8885 if (!nds32_get_local_syms (abfd, sec, &isymbuf))
8886 return FALSE;
8887
8888 /* Find the first relocation of the same relocation-type,
8889 so we iteratie them forward. */
8890 pc_rel = reloc;
8891 while ((pc_rel - 1) >= internal_relocs && pc_rel[-1].r_offset == offset)
8892 pc_rel--;
8893
8894 for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8895 {
8896 if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8897 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8898 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA
8899 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8900 {
8901 off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr);
8902 if (off >= ACCURATE_8BIT_S1 || off < -ACCURATE_8BIT_S1
8903 || off == 0)
8904 return FALSE;
8905 break;
8906 }
8907 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8908 {
8909 /* movi => movi55 */
8910 mem_addr = calculate_memory_address (abfd, pc_rel, isymbuf,
8911 symtab_hdr);
8912 /* mem_addr is unsigned, but the value should
8913 be between [-16, 15]. */
8914 if ((mem_addr + 0x10) >> 5)
8915 return FALSE;
8916 break;
8917 }
8918 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_20)
8919 || (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_LO12))
8920 {
8921 /* It never happen movi to movi55 for R_NDS32_TLS_LE_20,
8922 because it can be relaxed to addi for TLS_LE_ADD. */
8923 return FALSE;
8924 }
8925 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8926 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8927 && (reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG)
8928 && convert_type == SPECIAL_32_TO_16)
8929 {
8930 /* fp-as-gp
8931 We've selected a best fp-base for this access, so we can
8932 always resolve it anyway. Do nothing. */
8933 break;
8934 }
8935 else if ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_NONE
8936 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_RELA_GNU_VTINHERIT))
8937 || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_RELA_GNU_VTENTRY)
8938 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_INSN16))
8939 || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_LOADSTORE)
8940 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_DWARF2_OP1_RELA)))
8941 {
8942 /* Prevent unresolved addi instruction translate
8943 to addi45 or addi333. */
8944 return FALSE;
8945 }
8946 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8947 {
8948 off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr);
8949 if (off >= ACCURATE_U9BIT_S1 || off <= 0)
8950 return FALSE;
8951 break;
8952 }
8953 }
8954
8955 return TRUE;
8956 }
8957
8958 static void
8959 nds32_elf_write_16 (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *contents,
8960 Elf_Internal_Rela *reloc,
8961 Elf_Internal_Rela *internal_relocs,
8962 Elf_Internal_Rela *irelend,
8963 unsigned short insn16)
8964 {
8965 Elf_Internal_Rela *pc_rel;
8966 bfd_vma offset;
8967
8968 offset = reloc->r_offset;
8969 bfd_putb16 (insn16, contents + offset);
8970 /* Find the first relocation of the same relocation-type,
8971 so we iteratie them forward. */
8972 pc_rel = reloc;
8973 while ((pc_rel - 1) > internal_relocs && pc_rel[-1].r_offset == offset)
8974 pc_rel--;
8975
8976 for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8977 {
8978 if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8979 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8980 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA)
8981 {
8982 pc_rel->r_info =
8983 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PCREL_RELA);
8984 }
8985 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8986 pc_rel->r_info =
8987 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PLTREL);
8988 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8989 pc_rel->r_info =
8990 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_5_RELA);
8991 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8992 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8993 pc_rel->r_info =
8994 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_SDA_FP7U2_RELA);
8995 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8996 pc_rel->r_info =
8997 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_10IFCU_PCREL_RELA);
8998 }
8999 }
9000
9001 /* Find a relocation of type specified by `reloc_type'
9002 of the same r_offset with reloc.
9003 If not found, return irelend.
9004
9005 Assuming relocations are sorted by r_offset,
9006 we find the relocation from `reloc' backward untill relocs,
9007 or find it from `reloc' forward untill irelend. */
9008
9009 static Elf_Internal_Rela *
9010 find_relocs_at_address (Elf_Internal_Rela *reloc,
9011 Elf_Internal_Rela *relocs,
9012 Elf_Internal_Rela *irelend,
9013 enum elf_nds32_reloc_type reloc_type)
9014 {
9015 Elf_Internal_Rela *rel_t;
9016
9017 /* Find backward. */
9018 for (rel_t = reloc;
9019 rel_t >= relocs && rel_t->r_offset == reloc->r_offset;
9020 rel_t--)
9021 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
9022 return rel_t;
9023
9024 /* We didn't find it backward. Try find it forward. */
9025 for (rel_t = reloc;
9026 rel_t < irelend && rel_t->r_offset == reloc->r_offset;
9027 rel_t++)
9028 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
9029 return rel_t;
9030
9031 return irelend;
9032 }
9033
9034 /* Find a relocation of specified type and offset.
9035 `reloc' is just a refence point to find a relocation at specified offset.
9036 If not found, return irelend.
9037
9038 Assuming relocations are sorted by r_offset,
9039 we find the relocation from `reloc' backward untill relocs,
9040 or find it from `reloc' forward untill irelend. */
9041
9042 static Elf_Internal_Rela *
9043 find_relocs_at_address_addr (Elf_Internal_Rela *reloc,
9044 Elf_Internal_Rela *relocs,
9045 Elf_Internal_Rela *irelend,
9046 enum elf_nds32_reloc_type reloc_type,
9047 bfd_vma offset_p)
9048 {
9049 Elf_Internal_Rela *rel_t = NULL;
9050
9051 /* First, we try to find a relocation of offset `offset_p',
9052 and then we use find_relocs_at_address to find specific type. */
9053
9054 if (reloc->r_offset > offset_p)
9055 {
9056 /* Find backward. */
9057 for (rel_t = reloc;
9058 rel_t >= relocs && rel_t->r_offset > offset_p; rel_t--)
9059 /* Do nothing. */;
9060 }
9061 else if (reloc->r_offset < offset_p)
9062 {
9063 /* Find forward. */
9064 for (rel_t = reloc;
9065 rel_t < irelend && rel_t->r_offset < offset_p; rel_t++)
9066 /* Do nothing. */;
9067 }
9068 else
9069 rel_t = reloc;
9070
9071 /* Not found? */
9072 if (rel_t < relocs || rel_t == irelend || rel_t->r_offset != offset_p)
9073 return irelend;
9074
9075 return find_relocs_at_address (rel_t, relocs, irelend, reloc_type);
9076 }
9077
9078 typedef struct nds32_elf_blank nds32_elf_blank_t;
9079 struct nds32_elf_blank
9080 {
9081 /* Where the blank begins. */
9082 bfd_vma offset;
9083 /* The size of the blank. */
9084 bfd_vma size;
9085 /* The accumulative size before this blank. */
9086 bfd_vma total_size;
9087 nds32_elf_blank_t *next;
9088 nds32_elf_blank_t *prev;
9089 };
9090
9091 static nds32_elf_blank_t *blank_free_list = NULL;
9092
9093 static nds32_elf_blank_t *
9094 create_nds32_elf_blank (bfd_vma offset_p, bfd_vma size_p)
9095 {
9096 nds32_elf_blank_t *blank_t;
9097
9098 if (blank_free_list)
9099 {
9100 blank_t = blank_free_list;
9101 blank_free_list = blank_free_list->next;
9102 }
9103 else
9104 blank_t = bfd_malloc (sizeof (nds32_elf_blank_t));
9105
9106 if (blank_t == NULL)
9107 return NULL;
9108
9109 blank_t->offset = offset_p;
9110 blank_t->size = size_p;
9111 blank_t->total_size = 0;
9112 blank_t->next = NULL;
9113 blank_t->prev = NULL;
9114
9115 return blank_t;
9116 }
9117
9118 static void
9119 remove_nds32_elf_blank (nds32_elf_blank_t *blank_p)
9120 {
9121 if (blank_free_list)
9122 {
9123 blank_free_list->prev = blank_p;
9124 blank_p->next = blank_free_list;
9125 }
9126 else
9127 blank_p->next = NULL;
9128
9129 blank_p->prev = NULL;
9130 blank_free_list = blank_p;
9131 }
9132
9133 static void
9134 clean_nds32_elf_blank (void)
9135 {
9136 nds32_elf_blank_t *blank_t;
9137
9138 while (blank_free_list)
9139 {
9140 blank_t = blank_free_list;
9141 blank_free_list = blank_free_list->next;
9142 free (blank_t);
9143 }
9144 }
9145
9146 static nds32_elf_blank_t *
9147 search_nds32_elf_blank (nds32_elf_blank_t *blank_p, bfd_vma addr)
9148 {
9149 nds32_elf_blank_t *blank_t;
9150
9151 if (!blank_p)
9152 return NULL;
9153 blank_t = blank_p;
9154
9155 while (blank_t && addr < blank_t->offset)
9156 blank_t = blank_t->prev;
9157 while (blank_t && blank_t->next && addr >= blank_t->next->offset)
9158 blank_t = blank_t->next;
9159
9160 return blank_t;
9161 }
9162
9163 static bfd_vma
9164 get_nds32_elf_blank_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
9165 int overwrite)
9166 {
9167 nds32_elf_blank_t *blank_t;
9168
9169 blank_t = search_nds32_elf_blank (*blank_p, addr);
9170 if (!blank_t)
9171 return 0;
9172
9173 if (overwrite)
9174 *blank_p = blank_t;
9175
9176 if (addr < blank_t->offset + blank_t->size)
9177 return blank_t->total_size + (addr - blank_t->offset);
9178 else
9179 return blank_t->total_size + blank_t->size;
9180 }
9181
9182 static bfd_boolean
9183 insert_nds32_elf_blank (nds32_elf_blank_t **blank_p, bfd_vma addr, bfd_vma len)
9184 {
9185 nds32_elf_blank_t *blank_t, *blank_t2;
9186
9187 if (!*blank_p)
9188 {
9189 *blank_p = create_nds32_elf_blank (addr, len);
9190 return *blank_p ? TRUE : FALSE;
9191 }
9192
9193 blank_t = search_nds32_elf_blank (*blank_p, addr);
9194
9195 if (blank_t == NULL)
9196 {
9197 blank_t = create_nds32_elf_blank (addr, len);
9198 if (!blank_t)
9199 return FALSE;
9200 while ((*blank_p)->prev != NULL)
9201 *blank_p = (*blank_p)->prev;
9202 blank_t->next = *blank_p;
9203 (*blank_p)->prev = blank_t;
9204 (*blank_p) = blank_t;
9205 return TRUE;
9206 }
9207
9208 if (addr < blank_t->offset + blank_t->size)
9209 {
9210 /* Extend the origin blank. */
9211 if (addr + len > blank_t->offset + blank_t->size)
9212 blank_t->size = addr + len - blank_t->offset;
9213 }
9214 else
9215 {
9216 blank_t2 = create_nds32_elf_blank (addr, len);
9217 if (!blank_t2)
9218 return FALSE;
9219 if (blank_t->next)
9220 {
9221 blank_t->next->prev = blank_t2;
9222 blank_t2->next = blank_t->next;
9223 }
9224 blank_t2->prev = blank_t;
9225 blank_t->next = blank_t2;
9226 *blank_p = blank_t2;
9227 }
9228
9229 return TRUE;
9230 }
9231
9232 static bfd_boolean
9233 insert_nds32_elf_blank_recalc_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
9234 bfd_vma len)
9235 {
9236 nds32_elf_blank_t *blank_t;
9237
9238 if (!insert_nds32_elf_blank (blank_p, addr, len))
9239 return FALSE;
9240
9241 blank_t = *blank_p;
9242
9243 if (!blank_t->prev)
9244 {
9245 blank_t->total_size = 0;
9246 blank_t = blank_t->next;
9247 }
9248
9249 while (blank_t)
9250 {
9251 blank_t->total_size = blank_t->prev->total_size + blank_t->prev->size;
9252 blank_t = blank_t->next;
9253 }
9254
9255 return TRUE;
9256 }
9257
9258 static void
9259 calc_nds32_blank_total (nds32_elf_blank_t *blank_p)
9260 {
9261 nds32_elf_blank_t *blank_t;
9262 bfd_vma total_size = 0;
9263
9264 if (!blank_p)
9265 return;
9266
9267 blank_t = blank_p;
9268 while (blank_t->prev)
9269 blank_t = blank_t->prev;
9270 while (blank_t)
9271 {
9272 blank_t->total_size = total_size;
9273 total_size += blank_t->size;
9274 blank_t = blank_t->next;
9275 }
9276 }
9277
9278 static bfd_boolean
9279 nds32_elf_relax_delete_blanks (bfd *abfd, asection *sec,
9280 nds32_elf_blank_t *blank_p)
9281 {
9282 Elf_Internal_Shdr *symtab_hdr; /* Symbol table header of this bfd. */
9283 Elf_Internal_Sym *isym = NULL; /* Symbol table of this bfd. */
9284 Elf_Internal_Sym *isymend; /* Symbol entry iterator. */
9285 unsigned int sec_shndx; /* The section the be relaxed. */
9286 bfd_byte *contents; /* Contents data of iterating section. */
9287 Elf_Internal_Rela *internal_relocs;
9288 Elf_Internal_Rela *irel;
9289 Elf_Internal_Rela *irelend;
9290 struct elf_link_hash_entry **sym_hashes;
9291 struct elf_link_hash_entry **end_hashes;
9292 unsigned int symcount;
9293 asection *sect;
9294 nds32_elf_blank_t *blank_t;
9295 nds32_elf_blank_t *blank_t2;
9296 nds32_elf_blank_t *blank_head;
9297
9298 blank_head = blank_t = blank_p;
9299 while (blank_head->prev != NULL)
9300 blank_head = blank_head->prev;
9301 while (blank_t->next != NULL)
9302 blank_t = blank_t->next;
9303
9304 if (blank_t->offset + blank_t->size <= sec->size)
9305 {
9306 blank_t->next = create_nds32_elf_blank (sec->size + 4, 0);
9307 blank_t->next->prev = blank_t;
9308 }
9309 if (blank_head->offset > 0)
9310 {
9311 blank_head->prev = create_nds32_elf_blank (0, 0);
9312 blank_head->prev->next = blank_head;
9313 blank_head = blank_head->prev;
9314 }
9315
9316 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
9317
9318 /* The deletion must stop at the next ALIGN reloc for an alignment
9319 power larger than the number of bytes we are deleting. */
9320
9321 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9322 if (!nds32_get_local_syms (abfd, sec, &isym))
9323 return FALSE;
9324
9325 if (isym == NULL)
9326 {
9327 isym = bfd_elf_get_elf_syms (abfd, symtab_hdr,
9328 symtab_hdr->sh_info, 0, NULL, NULL, NULL);
9329 symtab_hdr->contents = (bfd_byte *) isym;
9330 }
9331
9332 if (isym == NULL || symtab_hdr->sh_info == 0)
9333 return FALSE;
9334
9335 blank_t = blank_head;
9336 calc_nds32_blank_total (blank_head);
9337
9338 for (sect = abfd->sections; sect != NULL; sect = sect->next)
9339 {
9340 /* Adjust all the relocs. */
9341
9342 /* Relocations MUST be kept in memory, because relaxation adjust them. */
9343 internal_relocs = _bfd_elf_link_read_relocs (abfd, sect, NULL, NULL,
9344 TRUE /* keep_memory */);
9345 irelend = internal_relocs + sect->reloc_count;
9346
9347 blank_t = blank_head;
9348 blank_t2 = blank_head;
9349
9350 if (!(sect->flags & SEC_RELOC))
9351 continue;
9352
9353 nds32_get_section_contents (abfd, sect, &contents, TRUE);
9354
9355 for (irel = internal_relocs; irel < irelend; irel++)
9356 {
9357 bfd_vma raddr;
9358
9359 if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_DIFF8
9360 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_DIFF32
9361 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
9362 {
9363 unsigned long val = 0;
9364 unsigned long mask;
9365 long before, between;
9366 long offset = 0;
9367
9368 switch (ELF32_R_TYPE (irel->r_info))
9369 {
9370 case R_NDS32_DIFF8:
9371 offset = bfd_get_8 (abfd, contents + irel->r_offset);
9372 break;
9373 case R_NDS32_DIFF16:
9374 offset = bfd_get_16 (abfd, contents + irel->r_offset);
9375 break;
9376 case R_NDS32_DIFF32:
9377 val = bfd_get_32 (abfd, contents + irel->r_offset);
9378 /* Get the signed bit and mask for the high part. The
9379 gcc will alarm when right shift 32-bit since the
9380 type size of long may be 32-bit. */
9381 mask = 0 - (val >> 31);
9382 if (mask)
9383 offset = (val | (mask - 0xffffffff));
9384 else
9385 offset = val;
9386 break;
9387 default:
9388 BFD_ASSERT (0);
9389 }
9390
9391 /* DIFF value
9392 0 |encoded in location|
9393 |------------|-------------------|---------
9394 sym+off(addend)
9395 -- before ---| *****************
9396 --------------------- between ---|
9397
9398 We only care how much data are relax between DIFF,
9399 marked as ***. */
9400
9401 before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
9402 between = get_nds32_elf_blank_total (&blank_t,
9403 irel->r_addend + offset, 0);
9404 if (between == before)
9405 goto done_adjust_diff;
9406
9407 switch (ELF32_R_TYPE (irel->r_info))
9408 {
9409 case R_NDS32_DIFF8:
9410 bfd_put_8 (abfd, offset - (between - before),
9411 contents + irel->r_offset);
9412 break;
9413 case R_NDS32_DIFF16:
9414 bfd_put_16 (abfd, offset - (between - before),
9415 contents + irel->r_offset);
9416 break;
9417 case R_NDS32_DIFF32:
9418 bfd_put_32 (abfd, offset - (between - before),
9419 contents + irel->r_offset);
9420 break;
9421 }
9422 }
9423 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_DIFF_ULEB128
9424 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
9425 {
9426 bfd_vma val = 0;
9427 unsigned int len = 0;
9428 unsigned long before, between;
9429 bfd_byte *endp, *p;
9430
9431 val = _bfd_read_unsigned_leb128 (abfd, contents + irel->r_offset,
9432 &len);
9433
9434 before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
9435 between = get_nds32_elf_blank_total (&blank_t,
9436 irel->r_addend + val, 0);
9437 if (between == before)
9438 goto done_adjust_diff;
9439
9440 p = contents + irel->r_offset;
9441 endp = p + len -1;
9442 memset (p, 0x80, len);
9443 *(endp) = 0;
9444 p = write_uleb128 (p, val - (between - before)) - 1;
9445 if (p < endp)
9446 *p |= 0x80;
9447 }
9448 done_adjust_diff:
9449
9450 if (sec == sect)
9451 {
9452 raddr = irel->r_offset;
9453 irel->r_offset -= get_nds32_elf_blank_total (&blank_t2,
9454 irel->r_offset, 1);
9455
9456 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
9457 continue;
9458 if (blank_t2 && blank_t2->next
9459 && (blank_t2->offset > raddr
9460 || blank_t2->next->offset <= raddr))
9461 _bfd_error_handler
9462 (_("%pB: error: search_nds32_elf_blank reports wrong node"),
9463 abfd);
9464
9465 /* Mark reloc in deleted portion as NONE.
9466 For some relocs like R_NDS32_LABEL that doesn't modify the
9467 content in the section. R_NDS32_LABEL doesn't belong to the
9468 instruction in the section, so we should preserve it. */
9469 if (raddr >= blank_t2->offset
9470 && raddr < blank_t2->offset + blank_t2->size
9471 && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL
9472 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_BEGIN
9473 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
9474 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
9475 && ELF32_R_TYPE (irel->r_info) != R_NDS32_SUBTRAHEND
9476 && ELF32_R_TYPE (irel->r_info) != R_NDS32_MINUEND)
9477 {
9478 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
9479 R_NDS32_NONE);
9480 continue;
9481 }
9482 }
9483
9484 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE
9485 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
9486 || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
9487 continue;
9488
9489 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info
9490 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx
9491 && ELF_ST_TYPE (isym[ELF32_R_SYM (irel->r_info)].st_info) == STT_SECTION)
9492 {
9493 if (irel->r_addend <= sec->size)
9494 irel->r_addend -=
9495 get_nds32_elf_blank_total (&blank_t, irel->r_addend, 1);
9496 }
9497 }
9498 }
9499
9500 /* Adjust the local symbols defined in this section. */
9501 blank_t = blank_head;
9502 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
9503 {
9504 if (isym->st_shndx == sec_shndx)
9505 {
9506 if (isym->st_value <= sec->size)
9507 {
9508 bfd_vma ahead;
9509 bfd_vma orig_addr = isym->st_value;
9510
9511 ahead = get_nds32_elf_blank_total (&blank_t, isym->st_value, 1);
9512 isym->st_value -= ahead;
9513
9514 /* Adjust function size. */
9515 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC
9516 && isym->st_size > 0)
9517 isym->st_size -=
9518 get_nds32_elf_blank_total
9519 (&blank_t, orig_addr + isym->st_size, 0) - ahead;
9520 }
9521 }
9522 }
9523
9524 /* Now adjust the global symbols defined in this section. */
9525 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
9526 - symtab_hdr->sh_info);
9527 sym_hashes = elf_sym_hashes (abfd);
9528 end_hashes = sym_hashes + symcount;
9529 blank_t = blank_head;
9530 for (; sym_hashes < end_hashes; sym_hashes++)
9531 {
9532 struct elf_link_hash_entry *sym_hash = *sym_hashes;
9533
9534 if ((sym_hash->root.type == bfd_link_hash_defined
9535 || sym_hash->root.type == bfd_link_hash_defweak)
9536 && sym_hash->root.u.def.section == sec)
9537 {
9538 if (sym_hash->root.u.def.value <= sec->size)
9539 {
9540 bfd_vma ahead;
9541 bfd_vma orig_addr = sym_hash->root.u.def.value;
9542
9543 ahead = get_nds32_elf_blank_total (&blank_t, sym_hash->root.u.def.value, 1);
9544 sym_hash->root.u.def.value -= ahead;
9545
9546 /* Adjust function size. */
9547 if (sym_hash->type == STT_FUNC)
9548 sym_hash->size -=
9549 get_nds32_elf_blank_total
9550 (&blank_t, orig_addr + sym_hash->size, 0) - ahead;
9551
9552 }
9553 }
9554 }
9555
9556 contents = elf_section_data (sec)->this_hdr.contents;
9557 blank_t = blank_head;
9558 while (blank_t->next)
9559 {
9560 /* Actually delete the bytes. */
9561
9562 /* If current blank is the last blank overlap with current section,
9563 go to finish process. */
9564 if (sec->size <= (blank_t->next->offset))
9565 break;
9566
9567 memmove (contents + blank_t->offset - blank_t->total_size,
9568 contents + blank_t->offset + blank_t->size,
9569 blank_t->next->offset - (blank_t->offset + blank_t->size));
9570
9571 blank_t = blank_t->next;
9572 }
9573
9574 if (sec->size > (blank_t->offset + blank_t->size))
9575 {
9576 /* There are remaining code between blank and section boundary.
9577 Move the remaining code to appropriate location. */
9578 memmove (contents + blank_t->offset - blank_t->total_size,
9579 contents + blank_t->offset + blank_t->size,
9580 sec->size - (blank_t->offset + blank_t->size));
9581 sec->size -= blank_t->total_size + blank_t->size;
9582 }
9583 else
9584 /* This blank is not entirely included in the section,
9585 reduce the section size by only part of the blank size. */
9586 sec->size -= blank_t->total_size + (sec->size - blank_t->offset);
9587
9588 while (blank_head)
9589 {
9590 blank_t = blank_head;
9591 blank_head = blank_head->next;
9592 remove_nds32_elf_blank (blank_t);
9593 }
9594
9595 return TRUE;
9596 }
9597
9598 /* Get the contents of a section. */
9599
9600 static int
9601 nds32_get_section_contents (bfd *abfd, asection *sec,
9602 bfd_byte **contents_p, bfd_boolean cache)
9603 {
9604 /* Get the section contents. */
9605 if (elf_section_data (sec)->this_hdr.contents != NULL)
9606 *contents_p = elf_section_data (sec)->this_hdr.contents;
9607 else
9608 {
9609 if (!bfd_malloc_and_get_section (abfd, sec, contents_p))
9610 return FALSE;
9611 if (cache)
9612 elf_section_data (sec)->this_hdr.contents = *contents_p;
9613 }
9614
9615 return TRUE;
9616 }
9617
9618 /* Get the contents of the internal symbol of abfd. */
9619
9620 static int
9621 nds32_get_local_syms (bfd *abfd, asection *sec ATTRIBUTE_UNUSED,
9622 Elf_Internal_Sym **isymbuf_p)
9623 {
9624 Elf_Internal_Shdr *symtab_hdr;
9625 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9626
9627 /* Read this BFD's local symbols if we haven't done so already. */
9628 if (*isymbuf_p == NULL && symtab_hdr->sh_info != 0)
9629 {
9630 *isymbuf_p = (Elf_Internal_Sym *) symtab_hdr->contents;
9631 if (*isymbuf_p == NULL)
9632 {
9633 *isymbuf_p = bfd_elf_get_elf_syms (abfd, symtab_hdr,
9634 symtab_hdr->sh_info, 0,
9635 NULL, NULL, NULL);
9636 if (*isymbuf_p == NULL)
9637 return FALSE;
9638 }
9639 }
9640 symtab_hdr->contents = (bfd_byte *) (*isymbuf_p);
9641
9642 return TRUE;
9643 }
9644
9645 /* Range of small data. */
9646 static bfd_vma sdata_range[2][2];
9647 static bfd_vma const sdata_init_range[2] =
9648 { ACCURATE_12BIT_S1, ACCURATE_19BIT };
9649
9650 static int
9651 nds32_elf_insn_size (bfd *abfd ATTRIBUTE_UNUSED,
9652 bfd_byte *contents, bfd_vma addr)
9653 {
9654 unsigned long insn = bfd_getb32 (contents + addr);
9655
9656 if (insn & 0x80000000)
9657 return 2;
9658
9659 return 4;
9660 }
9661
9662 /* Set the gp relax range. We have to measure the safe range
9663 to do gp relaxation. */
9664
9665 static void
9666 relax_range_measurement (bfd *abfd)
9667 {
9668 asection *sec_f, *sec_b;
9669 /* For upper bound. */
9670 bfd_vma maxpgsz = get_elf_backend_data (abfd)->maxpagesize;
9671 bfd_vma align;
9672 static int decide_relax_range = 0;
9673 int i;
9674 int range_number = ARRAY_SIZE (sdata_init_range);
9675
9676 if (decide_relax_range)
9677 return;
9678 decide_relax_range = 1;
9679
9680 if (sda_rela_sec == NULL)
9681 {
9682 /* Since there is no data sections, we assume the range is page size. */
9683 for (i = 0; i < range_number; i++)
9684 {
9685 sdata_range[i][0] = sdata_init_range[i] - 0x1000;
9686 sdata_range[i][1] = sdata_init_range[i] - 0x1000;
9687 }
9688 return;
9689 }
9690
9691 /* Get the biggest alignment power after the gp located section. */
9692 sec_f = sda_rela_sec->output_section;
9693 sec_b = sec_f->next;
9694 align = 0;
9695 while (sec_b != NULL)
9696 {
9697 if ((unsigned)(1 << sec_b->alignment_power) > align)
9698 align = (1 << sec_b->alignment_power);
9699 sec_b = sec_b->next;
9700 }
9701
9702 /* I guess we can not determine the section before
9703 gp located section, so we assume the align is max page size. */
9704 for (i = 0; i < range_number; i++)
9705 {
9706 sdata_range[i][1] = sdata_init_range[i] - align;
9707 BFD_ASSERT (sdata_range[i][1] <= sdata_init_range[i]);
9708 sdata_range[i][0] = sdata_init_range[i] - maxpgsz;
9709 BFD_ASSERT (sdata_range[i][0] <= sdata_init_range[i]);
9710 }
9711 }
9712
9713 /* These are macros used to check flags encoded in r_addend.
9714 They are only used by nds32_elf_relax_section (). */
9715 #define GET_SEQ_LEN(addend) ((addend) & 0x000000ff)
9716 #define IS_1ST_CONVERT(addend) ((addend) & 0x80000000)
9717 #define IS_OPTIMIZE(addend) ((addend) & 0x40000000)
9718 #define IS_16BIT_ON(addend) ((addend) & 0x20000000)
9719
9720 static const char * unrecognized_reloc_msg =
9721 /* xgettext:c-format */
9722 N_("%pB: warning: %s points to unrecognized reloc at %#" PRIx64);
9723
9724 /* Relax LONGCALL1 relocation for nds32_elf_relax_section. */
9725
9726 static bfd_boolean
9727 nds32_elf_relax_longcall1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9728 Elf_Internal_Rela *internal_relocs, int *insn_len,
9729 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9730 Elf_Internal_Shdr *symtab_hdr)
9731 {
9732 /* There are 3 variations for LONGCALL1
9733 case 4-4-2; 16-bit on, optimize off or optimize for space
9734 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9735 ori ta, ta, lo12(symbol) ; LO12S0
9736 jral5 ta ;
9737
9738 case 4-4-4; 16-bit off, optimize don't care
9739 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9740 ori ta, ta, lo12(symbol) ; LO12S0
9741 jral ta ;
9742
9743 case 4-4-4; 16-bit on, optimize for speed
9744 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9745 ori ta, ta, lo12(symbol) ; LO12S0
9746 jral ta ;
9747 Check code for -mlong-calls output. */
9748
9749 /* Get the reloc for the address from which the register is
9750 being loaded. This reloc will tell us which function is
9751 actually being called. */
9752
9753 bfd_vma laddr;
9754 int seq_len; /* Original length of instruction sequence. */
9755 uint32_t insn;
9756 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9757 bfd_signed_vma foff;
9758 uint16_t insn16;
9759
9760 irelend = internal_relocs + sec->reloc_count;
9761 seq_len = GET_SEQ_LEN (irel->r_addend);
9762 laddr = irel->r_offset;
9763 *insn_len = seq_len;
9764
9765 hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9766 R_NDS32_HI20_RELA, laddr);
9767 lo_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9768 R_NDS32_LO12S0_ORI_RELA,
9769 laddr + 4);
9770
9771 if (hi_irelfn == irelend || lo_irelfn == irelend)
9772 {
9773 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL1",
9774 (uint64_t) irel->r_offset);
9775 return FALSE;
9776 }
9777
9778 /* Get the value of the symbol referred to by the reloc. */
9779 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
9780
9781 /* This condition only happened when symbol is undefined. */
9782 if (foff == 0
9783 || foff < -CONSERVATIVE_24BIT_S1
9784 || foff >= CONSERVATIVE_24BIT_S1)
9785 return FALSE;
9786
9787 /* Relax to: jal symbol; 25_PCREL. */
9788 /* For simplicity of coding, we are going to modify the section
9789 contents, the section relocs, and the BFD symbol table. We
9790 must tell the rest of the code not to free up this
9791 information. It would be possible to instead create a table
9792 of changes which have to be made, as is done in coff-mips.c;
9793 that would be more work, but would require less memory when
9794 the linker is run. */
9795
9796 /* Replace the long call with a jal. */
9797 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9798 R_NDS32_25_PCREL_RELA);
9799 irel->r_addend = hi_irelfn->r_addend;
9800
9801 /* We don't resolve this here but resolve it in relocate_section. */
9802 insn = INSN_JAL;
9803 bfd_putb32 (insn, contents + irel->r_offset);
9804
9805 hi_irelfn->r_info =
9806 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9807 lo_irelfn->r_info =
9808 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9809 *insn_len = 4;
9810
9811 if (seq_len & 0x2)
9812 {
9813 insn16 = NDS32_NOP16;
9814 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9815 lo_irelfn->r_info =
9816 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9817 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9818 *insn_len += 2;
9819 }
9820 return TRUE;
9821 }
9822
9823 #define CONVERT_CONDITION_CALL(insn) (((insn) & 0xffff0000) ^ 0x90000)
9824 /* Relax LONGCALL2 relocation for nds32_elf_relax_section. */
9825
9826 static bfd_boolean
9827 nds32_elf_relax_longcall2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9828 Elf_Internal_Rela *internal_relocs, int *insn_len,
9829 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9830 Elf_Internal_Shdr *symtab_hdr)
9831 {
9832 /* bltz rt, .L1 ; LONGCALL2
9833 jal symbol ; 25_PCREL
9834 .L1: */
9835
9836 /* Get the reloc for the address from which the register is
9837 being loaded. This reloc will tell us which function is
9838 actually being called. */
9839
9840 bfd_vma laddr;
9841 uint32_t insn;
9842 Elf_Internal_Rela *i1_irelfn, *cond_irelfn, *irelend;
9843 bfd_signed_vma foff;
9844
9845 irelend = internal_relocs + sec->reloc_count;
9846 laddr = irel->r_offset;
9847 i1_irelfn =
9848 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9849 R_NDS32_25_PCREL_RELA, laddr + 4);
9850
9851 if (i1_irelfn == irelend)
9852 {
9853 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL2",
9854 (uint64_t) irel->r_offset);
9855 return FALSE;
9856 }
9857
9858 insn = bfd_getb32 (contents + laddr);
9859
9860 /* Get the value of the symbol referred to by the reloc. */
9861 foff = calculate_offset (abfd, sec, i1_irelfn, isymbuf, symtab_hdr);
9862
9863 if (foff == 0
9864 || foff < -CONSERVATIVE_16BIT_S1
9865 || foff >= CONSERVATIVE_16BIT_S1)
9866 return FALSE;
9867
9868 /* Relax to bgezal rt, label ; 17_PCREL
9869 or bltzal rt, label ; 17_PCREL */
9870
9871 /* Convert to complimentary conditional call. */
9872 insn = CONVERT_CONDITION_CALL (insn);
9873
9874 /* For simplicity of coding, we are going to modify the section
9875 contents, the section relocs, and the BFD symbol table. We
9876 must tell the rest of the code not to free up this
9877 information. It would be possible to instead create a table
9878 of changes which have to be made, as is done in coff-mips.c;
9879 that would be more work, but would require less memory when
9880 the linker is run. */
9881
9882 /* Clean unnessary relocations. */
9883 i1_irelfn->r_info =
9884 ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info), R_NDS32_NONE);
9885 cond_irelfn =
9886 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9887 R_NDS32_17_PCREL_RELA, laddr);
9888 if (cond_irelfn != irelend)
9889 cond_irelfn->r_info =
9890 ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info), R_NDS32_NONE);
9891
9892 /* Replace the long call with a bgezal. */
9893 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info),
9894 R_NDS32_17_PCREL_RELA);
9895 irel->r_addend = i1_irelfn->r_addend;
9896
9897 bfd_putb32 (insn, contents + irel->r_offset);
9898
9899 *insn_len = 4;
9900 return TRUE;
9901 }
9902
9903 /* Relax LONGCALL3 relocation for nds32_elf_relax_section. */
9904
9905 static bfd_boolean
9906 nds32_elf_relax_longcall3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9907 Elf_Internal_Rela *internal_relocs, int *insn_len,
9908 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9909 Elf_Internal_Shdr *symtab_hdr)
9910 {
9911 /* There are 3 variations for LONGCALL3
9912 case 4-4-4-2; 16-bit on, optimize off or optimize for space
9913 bltz rt, $1 ; LONGCALL3
9914 sethi ta, hi20(symbol) ; HI20
9915 ori ta, ta, lo12(symbol) ; LO12S0
9916 jral5 ta ;
9917 $1
9918
9919 case 4-4-4-4; 16-bit off, optimize don't care
9920 bltz rt, $1 ; LONGCALL3
9921 sethi ta, hi20(symbol) ; HI20
9922 ori ta, ta, lo12(symbol) ; LO12S0
9923 jral ta ;
9924 $1
9925
9926 case 4-4-4-4; 16-bit on, optimize for speed
9927 bltz rt, $1 ; LONGCALL3
9928 sethi ta, hi20(symbol) ; HI20
9929 ori ta, ta, lo12(symbol) ; LO12S0
9930 jral ta ;
9931 $1 */
9932
9933 /* Get the reloc for the address from which the register is
9934 being loaded. This reloc will tell us which function is
9935 actually being called. */
9936
9937 bfd_vma laddr;
9938 int seq_len; /* Original length of instruction sequence. */
9939 uint32_t insn;
9940 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9941 bfd_signed_vma foff;
9942 uint16_t insn16;
9943
9944 irelend = internal_relocs + sec->reloc_count;
9945 seq_len = GET_SEQ_LEN (irel->r_addend);
9946 laddr = irel->r_offset;
9947 *insn_len = seq_len;
9948
9949 hi_irelfn =
9950 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9951 R_NDS32_HI20_RELA, laddr + 4);
9952 lo_irelfn =
9953 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9954 R_NDS32_LO12S0_ORI_RELA, laddr + 8);
9955
9956 if (hi_irelfn == irelend || lo_irelfn == irelend)
9957 {
9958 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL3",
9959 (uint64_t) irel->r_offset);
9960 return FALSE;
9961 }
9962
9963 /* Get the value of the symbol referred to by the reloc. */
9964 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
9965
9966 if (foff == 0
9967 || foff < -CONSERVATIVE_24BIT_S1
9968 || foff >= CONSERVATIVE_24BIT_S1)
9969 return FALSE;
9970
9971 insn = bfd_getb32 (contents + laddr);
9972 if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
9973 {
9974 /* Relax to bgezal rt, label ; 17_PCREL
9975 or bltzal rt, label ; 17_PCREL */
9976
9977 /* Convert to complimentary conditional call. */
9978 insn = CONVERT_CONDITION_CALL (insn);
9979 bfd_putb32 (insn, contents + irel->r_offset);
9980
9981 *insn_len = 4;
9982 irel->r_info =
9983 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9984 hi_irelfn->r_info =
9985 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9986 lo_irelfn->r_info =
9987 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9988
9989 cond_irelfn =
9990 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9991 R_NDS32_17_PCREL_RELA, laddr);
9992 if (cond_irelfn != irelend)
9993 {
9994 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9995 R_NDS32_17_PCREL_RELA);
9996 cond_irelfn->r_addend = hi_irelfn->r_addend;
9997 }
9998
9999 if (seq_len & 0x2)
10000 {
10001 insn16 = NDS32_NOP16;
10002 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10003 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10004 R_NDS32_INSN16);
10005 hi_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10006 insn_len += 2;
10007 }
10008 }
10009 else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
10010 {
10011 /* Relax to the following instruction sequence
10012 bltz rt, $1 ; LONGCALL2
10013 jal symbol ; 25_PCREL
10014 $1 */
10015 *insn_len = 8;
10016 insn = INSN_JAL;
10017 bfd_putb32 (insn, contents + hi_irelfn->r_offset);
10018
10019 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10020 R_NDS32_25_PCREL_RELA);
10021 irel->r_info =
10022 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL2);
10023
10024 lo_irelfn->r_info =
10025 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
10026
10027 if (seq_len & 0x2)
10028 {
10029 insn16 = NDS32_NOP16;
10030 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10031 lo_irelfn->r_info =
10032 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
10033 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10034 insn_len += 2;
10035 }
10036 }
10037 return TRUE;
10038 }
10039
10040 /* Relax LONGJUMP1 relocation for nds32_elf_relax_section. */
10041
10042 static bfd_boolean
10043 nds32_elf_relax_longjump1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10044 Elf_Internal_Rela *internal_relocs, int *insn_len,
10045 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10046 Elf_Internal_Shdr *symtab_hdr)
10047 {
10048 /* There are 3 variations for LONGJUMP1
10049 case 4-4-2; 16-bit bit on, optimize off or optimize for space
10050 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
10051 ori ta, ta, lo12(symbol) ; LO12S0
10052 jr5 ta ;
10053
10054 case 4-4-4; 16-bit off, optimize don't care
10055 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
10056 ori ta, ta, lo12(symbol) ; LO12S0
10057 jr ta ;
10058
10059 case 4-4-4; 16-bit on, optimize for speed
10060 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
10061 ori ta, ta, lo12(symbol) ; LO12S0
10062 jr ta ; */
10063
10064 /* Get the reloc for the address from which the register is
10065 being loaded. This reloc will tell us which function is
10066 actually being called. */
10067
10068 bfd_vma laddr;
10069 int seq_len; /* Original length of instruction sequence. */
10070 int insn16_on; /* 16-bit on/off. */
10071 uint32_t insn;
10072 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
10073 bfd_signed_vma foff;
10074 uint16_t insn16;
10075 unsigned long reloc;
10076
10077 irelend = internal_relocs + sec->reloc_count;
10078 seq_len = GET_SEQ_LEN (irel->r_addend);
10079 laddr = irel->r_offset;
10080 *insn_len = seq_len;
10081 insn16_on = IS_16BIT_ON (irel->r_addend);
10082
10083 hi_irelfn =
10084 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10085 R_NDS32_HI20_RELA, laddr);
10086 lo_irelfn =
10087 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10088 R_NDS32_LO12S0_ORI_RELA, laddr + 4);
10089 if (hi_irelfn == irelend || lo_irelfn == irelend)
10090 {
10091 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP1",
10092 (uint64_t) irel->r_offset);
10093 return FALSE;
10094 }
10095
10096 /* Get the value of the symbol referred to by the reloc. */
10097 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
10098
10099 if (foff == 0
10100 || foff >= CONSERVATIVE_24BIT_S1
10101 || foff < -CONSERVATIVE_24BIT_S1)
10102 return FALSE;
10103
10104 if (insn16_on
10105 && foff >= -ACCURATE_8BIT_S1
10106 && foff < ACCURATE_8BIT_S1
10107 && (seq_len & 0x2))
10108 {
10109 /* j8 label */
10110 /* 16-bit on, but not optimized for speed. */
10111 reloc = R_NDS32_9_PCREL_RELA;
10112 insn16 = INSN_J8;
10113 bfd_putb16 (insn16, contents + irel->r_offset);
10114 *insn_len = 2;
10115 irel->r_info =
10116 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10117 }
10118 else
10119 {
10120 /* j label */
10121 reloc = R_NDS32_25_PCREL_RELA;
10122 insn = INSN_J;
10123 bfd_putb32 (insn, contents + irel->r_offset);
10124 *insn_len = 4;
10125 irel->r_info =
10126 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_INSN16);
10127 irel->r_addend = 0;
10128 }
10129
10130 hi_irelfn->r_info =
10131 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
10132 lo_irelfn->r_info =
10133 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
10134
10135 if ((seq_len & 0x2) && ((*insn_len & 2) == 0))
10136 {
10137 insn16 = NDS32_NOP16;
10138 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10139 lo_irelfn->r_info =
10140 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
10141 R_NDS32_INSN16);
10142 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10143 *insn_len += 2;
10144 }
10145 return TRUE;
10146 }
10147
10148 /* Revert condition branch. This function does not check if the input
10149 instruction is condition branch or not. */
10150
10151 static void
10152 nds32_elf_convert_branch (uint16_t insn16, uint32_t insn,
10153 uint16_t *re_insn16, uint32_t *re_insn)
10154 {
10155 uint32_t comp_insn = 0;
10156 uint16_t comp_insn16 = 0;
10157
10158 if (insn)
10159 {
10160 if (N32_OP6 (insn) == N32_OP6_BR1)
10161 {
10162 /* beqs label. */
10163 comp_insn = (insn ^ 0x4000) & 0xffffc000;
10164 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5)
10165 {
10166 /* Insn can be contracted to 16-bit implied r5. */
10167 comp_insn16 =
10168 (comp_insn & 0x4000) ? INSN_BNES38 : INSN_BEQS38;
10169 comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
10170 }
10171 }
10172 else if (N32_OP6 (insn) == N32_OP6_BR3)
10173 {
10174 /* bnec $ta, imm11, label. */
10175 comp_insn = (insn ^ 0x80000) & 0xffffff00;
10176 }
10177 else
10178 {
10179 comp_insn = (insn ^ 0x10000) & 0xffffc000;
10180 if (N32_BR2_SUB (insn) == N32_BR2_BEQZ
10181 || N32_BR2_SUB (insn) == N32_BR2_BNEZ)
10182 {
10183 if (N32_IS_RT3 (insn))
10184 {
10185 /* Insn can be contracted to 16-bit. */
10186 comp_insn16 =
10187 (comp_insn & 0x10000) ? INSN_BNEZ38 : INSN_BEQZ38;
10188 comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
10189 }
10190 else if (N32_RT5 (insn) == REG_R15)
10191 {
10192 /* Insn can be contracted to 16-bit. */
10193 comp_insn16 =
10194 (comp_insn & 0x10000) ? INSN_BNES38 : INSN_BEQS38;
10195 }
10196 }
10197 }
10198 }
10199 else
10200 {
10201 switch ((insn16 & 0xf000) >> 12)
10202 {
10203 case 0xc:
10204 /* beqz38 or bnez38 */
10205 comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
10206 comp_insn = (comp_insn16 & 0x0800) ? INSN_BNEZ : INSN_BEQZ;
10207 comp_insn |= ((comp_insn16 & 0x0700) >> 8) << 20;
10208 break;
10209
10210 case 0xd:
10211 /* beqs38 or bnes38 */
10212 comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
10213 comp_insn = (comp_insn16 & 0x0800) ? INSN_BNE : INSN_BEQ;
10214 comp_insn |= (((comp_insn16 & 0x0700) >> 8) << 20)
10215 | (REG_R5 << 15);
10216 break;
10217
10218 case 0xe:
10219 /* beqzS8 or bnezS8 */
10220 comp_insn16 = (insn16 ^ 0x0100) & 0xff00;
10221 comp_insn = (comp_insn16 & 0x0100) ? INSN_BNEZ : INSN_BEQZ;
10222 comp_insn |= REG_R15 << 20;
10223 break;
10224
10225 default:
10226 break;
10227 }
10228 }
10229 if (comp_insn && re_insn)
10230 *re_insn = comp_insn;
10231 if (comp_insn16 && re_insn16)
10232 *re_insn16 = comp_insn16;
10233 }
10234
10235 /* Relax LONGJUMP2 relocation for nds32_elf_relax_section. */
10236
10237 static bfd_boolean
10238 nds32_elf_relax_longjump2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10239 Elf_Internal_Rela *internal_relocs, int *insn_len,
10240 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10241 Elf_Internal_Shdr *symtab_hdr)
10242 {
10243 /* There are 3 variations for LONGJUMP2
10244 case 2-4; 1st insn convertible, 16-bit on,
10245 optimize off or optimize for space
10246 bnes38 rt, ra, $1 ; LONGJUMP2
10247 j label ; 25_PCREL
10248 $1:
10249
10250 case 4-4; 1st insn not convertible
10251 bne rt, ra, $1 ; LONGJUMP2
10252 j label ; 25_PCREL
10253 $1:
10254
10255 case 4-4; 1st insn convertible, 16-bit on, optimize for speed
10256 bne rt, ra, $1 ; LONGJUMP2
10257 j label ; 25_PCREL
10258 $1: */
10259
10260 /* Get the reloc for the address from which the register is
10261 being loaded. This reloc will tell us which function is
10262 actually being called. */
10263
10264 bfd_vma laddr;
10265 int seq_len; /* Original length of instruction sequence. */
10266 Elf_Internal_Rela *i2_irelfn, *cond_irelfn, *irelend;
10267 int first_size;
10268 unsigned int i;
10269 bfd_signed_vma foff;
10270 uint32_t insn, re_insn = 0;
10271 uint16_t insn16, re_insn16 = 0;
10272 unsigned long reloc, cond_reloc;
10273
10274 enum elf_nds32_reloc_type checked_types[] =
10275 { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
10276
10277 irelend = internal_relocs + sec->reloc_count;
10278 seq_len = GET_SEQ_LEN (irel->r_addend);
10279 laddr = irel->r_offset;
10280 *insn_len = seq_len;
10281 first_size = (seq_len == 6) ? 2 : 4;
10282
10283 i2_irelfn =
10284 find_relocs_at_address_addr (irel, internal_relocs,
10285 irelend, R_NDS32_25_PCREL_RELA,
10286 laddr + first_size);
10287
10288 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
10289 {
10290 cond_irelfn =
10291 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10292 checked_types[i], laddr);
10293 if (cond_irelfn != irelend)
10294 break;
10295 }
10296
10297 if (i2_irelfn == irelend || cond_irelfn == irelend)
10298 {
10299 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP2",
10300 (uint64_t) irel->r_offset);
10301 return FALSE;
10302 }
10303
10304 /* Get the value of the symbol referred to by the reloc. */
10305 foff = calculate_offset (abfd, sec, i2_irelfn, isymbuf, symtab_hdr);
10306 if (foff == 0
10307 || foff < -CONSERVATIVE_16BIT_S1
10308 || foff >= CONSERVATIVE_16BIT_S1)
10309 return FALSE;
10310
10311 /* Get the all corresponding instructions. */
10312 if (first_size == 4)
10313 {
10314 insn = bfd_getb32 (contents + laddr);
10315 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10316 }
10317 else
10318 {
10319 insn16 = bfd_getb16 (contents + laddr);
10320 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10321 }
10322
10323 if (re_insn16 && foff >= -(ACCURATE_8BIT_S1 - first_size)
10324 && foff < ACCURATE_8BIT_S1 - first_size)
10325 {
10326 if (first_size == 4)
10327 {
10328 /* Don't convert it to 16-bit now, keep this as relaxable for
10329 ``label reloc; INSN16''. */
10330
10331 /* Save comp_insn32 to buffer. */
10332 bfd_putb32 (re_insn, contents + irel->r_offset);
10333 *insn_len = 4;
10334 reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
10335 R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
10336 cond_reloc = R_NDS32_INSN16;
10337 }
10338 else
10339 {
10340 bfd_putb16 (re_insn16, contents + irel->r_offset);
10341 *insn_len = 2;
10342 reloc = R_NDS32_9_PCREL_RELA;
10343 cond_reloc = R_NDS32_NONE;
10344 }
10345 }
10346 else if (N32_OP6 (re_insn) == N32_OP6_BR1
10347 && (foff >= -(ACCURATE_14BIT_S1 - first_size)
10348 && foff < ACCURATE_14BIT_S1 - first_size))
10349 {
10350 /* beqs label ; 15_PCREL */
10351 bfd_putb32 (re_insn, contents + irel->r_offset);
10352 *insn_len = 4;
10353 reloc = R_NDS32_15_PCREL_RELA;
10354 cond_reloc = R_NDS32_NONE;
10355 }
10356 else if (N32_OP6 (re_insn) == N32_OP6_BR2
10357 && foff >= -CONSERVATIVE_16BIT_S1
10358 && foff < CONSERVATIVE_16BIT_S1)
10359 {
10360 /* beqz label ; 17_PCREL */
10361 bfd_putb32 (re_insn, contents + irel->r_offset);
10362 *insn_len = 4;
10363 reloc = R_NDS32_17_PCREL_RELA;
10364 cond_reloc = R_NDS32_NONE;
10365 }
10366 else
10367 return FALSE;
10368
10369 /* Set all relocations. */
10370 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info), reloc);
10371 irel->r_addend = i2_irelfn->r_addend;
10372
10373 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
10374 cond_reloc);
10375 cond_irelfn->r_addend = 0;
10376
10377 if ((seq_len ^ *insn_len ) & 0x2)
10378 {
10379 insn16 = NDS32_NOP16;
10380 bfd_putb16 (insn16, contents + irel->r_offset + 4);
10381 i2_irelfn->r_offset = 4;
10382 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
10383 R_NDS32_INSN16);
10384 i2_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10385 *insn_len += 2;
10386 }
10387 else
10388 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
10389 R_NDS32_NONE);
10390 return TRUE;
10391 }
10392
10393 /* Relax LONGJUMP3 relocation for nds32_elf_relax_section. */
10394
10395 static bfd_boolean
10396 nds32_elf_relax_longjump3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10397 Elf_Internal_Rela *internal_relocs, int *insn_len,
10398 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10399 Elf_Internal_Shdr *symtab_hdr)
10400 {
10401 /* There are 5 variations for LONGJUMP3
10402 case 1: 2-4-4-2; 1st insn convertible, 16-bit on,
10403 optimize off or optimize for space
10404 bnes38 rt, ra, $1 ; LONGJUMP3
10405 sethi ta, hi20(symbol) ; HI20
10406 ori ta, ta, lo12(symbol) ; LO12S0
10407 jr5 ta ;
10408 $1: ;
10409
10410 case 2: 2-4-4-2; 1st insn convertible, 16-bit on, optimize for speed
10411 bnes38 rt, ra, $1 ; LONGJUMP3
10412 sethi ta, hi20(symbol) ; HI20
10413 ori ta, ta, lo12(symbol) ; LO12S0
10414 jr5 ta ;
10415 $1: ; LABEL
10416
10417 case 3: 4-4-4-2; 1st insn not convertible, 16-bit on,
10418 optimize off or optimize for space
10419 bne 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 4: 4-4-4-4; 1st insn don't care, 16-bit off, optimize don't care
10426 16-bit off if no INSN16
10427 bne rt, ra, $1 ; LONGJUMP3
10428 sethi ta, hi20(symbol) ; HI20
10429 ori ta, ta, lo12(symbol) ; LO12S0
10430 jr ta ;
10431 $1: ;
10432
10433 case 5: 4-4-4-4; 1st insn not convertible, 16-bit on, optimize for speed
10434 16-bit off if no INSN16
10435 bne rt, ra, $1 ; LONGJUMP3
10436 sethi ta, hi20(symbol) ; HI20
10437 ori ta, ta, lo12(symbol) ; LO12S0
10438 jr ta ;
10439 $1: ; LABEL */
10440
10441 /* Get the reloc for the address from which the register is
10442 being loaded. This reloc will tell us which function is
10443 actually being called. */
10444 enum elf_nds32_reloc_type checked_types[] =
10445 { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
10446
10447 int reloc_off = 0, cond_removed = 0, convertible;
10448 bfd_vma laddr;
10449 int seq_len; /* Original length of instruction sequence. */
10450 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
10451 int first_size;
10452 unsigned int i;
10453 bfd_signed_vma foff;
10454 uint32_t insn, re_insn = 0;
10455 uint16_t insn16, re_insn16 = 0;
10456 unsigned long reloc, cond_reloc;
10457
10458 irelend = internal_relocs + sec->reloc_count;
10459 seq_len = GET_SEQ_LEN (irel->r_addend);
10460 laddr = irel->r_offset;
10461 *insn_len = seq_len;
10462
10463 convertible = IS_1ST_CONVERT (irel->r_addend);
10464
10465 if (convertible)
10466 first_size = 2;
10467 else
10468 first_size = 4;
10469
10470 /* Get all needed relocations. */
10471 hi_irelfn =
10472 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10473 R_NDS32_HI20_RELA, laddr + first_size);
10474 lo_irelfn =
10475 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10476 R_NDS32_LO12S0_ORI_RELA,
10477 laddr + first_size + 4);
10478
10479 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
10480 {
10481 cond_irelfn =
10482 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10483 checked_types[i], laddr);
10484 if (cond_irelfn != irelend)
10485 break;
10486 }
10487
10488 if (hi_irelfn == irelend
10489 || lo_irelfn == irelend
10490 || cond_irelfn == irelend)
10491 {
10492 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP3",
10493 (uint64_t) irel->r_offset);
10494 return FALSE;
10495 }
10496
10497 /* Get the value of the symbol referred to by the reloc. */
10498 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr);
10499
10500 if (foff == 0
10501 || foff < -CONSERVATIVE_24BIT_S1
10502 || foff >= CONSERVATIVE_24BIT_S1)
10503 return FALSE;
10504
10505 /* Get the all corresponding instructions. */
10506 if (first_size == 4)
10507 {
10508 insn = bfd_getb32 (contents + laddr);
10509 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10510 }
10511 else
10512 {
10513 insn16 = bfd_getb16 (contents + laddr);
10514 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10515 }
10516
10517 /* For simplicity of coding, we are going to modify the section
10518 contents, the section relocs, and the BFD symbol table. We
10519 must tell the rest of the code not to free up this
10520 information. It would be possible to instead create a table
10521 of changes which have to be made, as is done in coff-mips.c;
10522 that would be more work, but would require less memory when
10523 the linker is run. */
10524
10525 if (re_insn16
10526 && foff >= -ACCURATE_8BIT_S1 - first_size
10527 && foff < ACCURATE_8BIT_S1 - first_size)
10528 {
10529 if (!(seq_len & 0x2))
10530 {
10531 /* Don't convert it to 16-bit now, keep this as relaxable
10532 for ``label reloc; INSN1a''6. */
10533 /* Save comp_insn32 to buffer. */
10534 bfd_putb32 (re_insn, contents + irel->r_offset);
10535 *insn_len = 4;
10536 reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
10537 R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
10538 cond_reloc = R_NDS32_INSN16;
10539 }
10540 else
10541 {
10542 /* Not optimize for speed; convert sequence to 16-bit. */
10543 /* Save comp_insn16 to buffer. */
10544 bfd_putb16 (re_insn16, contents + irel->r_offset);
10545 *insn_len = 2;
10546 reloc = R_NDS32_9_PCREL_RELA;
10547 cond_reloc = R_NDS32_NONE;
10548 }
10549 cond_removed = 1;
10550 }
10551 else if (N32_OP6 (re_insn) == N32_OP6_BR1
10552 && (foff >= -(ACCURATE_14BIT_S1 - first_size)
10553 && foff < ACCURATE_14BIT_S1 - first_size))
10554 {
10555 /* beqs label ; 15_PCREL */
10556 bfd_putb32 (re_insn, contents + irel->r_offset);
10557 *insn_len = 4;
10558 reloc = R_NDS32_15_PCREL_RELA;
10559 cond_reloc = R_NDS32_NONE;
10560 cond_removed = 1;
10561 }
10562 else if (N32_OP6 (re_insn) == N32_OP6_BR2
10563 && foff >= -CONSERVATIVE_16BIT_S1
10564 && foff < CONSERVATIVE_16BIT_S1)
10565 {
10566 /* beqz label ; 17_PCREL */
10567 bfd_putb32 (re_insn, contents + irel->r_offset);
10568 *insn_len = 4;
10569 reloc = R_NDS32_17_PCREL_RELA;
10570 cond_reloc = R_NDS32_NONE;
10571 cond_removed = 1;
10572 }
10573 else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
10574 && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
10575 {
10576 /* Relax to one of the following 3 variations
10577
10578 case 2-4; 1st insn convertible, 16-bit on, optimize off or optimize
10579 for space
10580 bnes38 rt, $1 ; LONGJUMP2
10581 j label ; 25_PCREL
10582 $1
10583
10584 case 4-4; 1st insn not convertible, others don't care
10585 bne rt, ra, $1 ; LONGJUMP2
10586 j label ; 25_PCREL
10587 $1
10588
10589 case 4-4; 1st insn convertible, 16-bit on, optimize for speed
10590 bne rt, ra, $1 ; LONGJUMP2
10591 j label ; 25_PCREL
10592 $1 */
10593
10594 /* Offset for first instruction. */
10595
10596 /* Use j label as second instruction. */
10597 *insn_len = 4 + first_size;
10598 insn = INSN_J;
10599 bfd_putb32 (insn, contents + hi_irelfn->r_offset);
10600 reloc = R_NDS32_LONGJUMP2;
10601 cond_reloc = R_NDS32_25_PLTREL;
10602 }
10603 else
10604 return FALSE;
10605
10606 if (cond_removed == 1)
10607 {
10608 /* Set all relocations. */
10609 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
10610 irel->r_addend = hi_irelfn->r_addend;
10611
10612 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
10613 cond_reloc);
10614 cond_irelfn->r_addend = 0;
10615 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10616 R_NDS32_NONE);
10617 }
10618 else
10619 {
10620 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
10621 irel->r_addend = irel->r_addend;
10622 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
10623 cond_reloc);
10624 }
10625
10626 if ((seq_len ^ *insn_len ) & 0x2)
10627 {
10628 insn16 = NDS32_NOP16;
10629 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
10630 lo_irelfn->r_offset = *insn_len;
10631 lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
10632 R_NDS32_INSN16);
10633 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10634 *insn_len += 2;
10635 }
10636 else
10637 lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
10638 R_NDS32_NONE);
10639 return TRUE;
10640 }
10641
10642 /* Relax LONGCALL4 relocation for nds32_elf_relax_section. */
10643
10644 static bfd_boolean
10645 nds32_elf_relax_longcall4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10646 Elf_Internal_Rela *internal_relocs, int *insn_len,
10647 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10648 Elf_Internal_Shdr *symtab_hdr)
10649 {
10650 /* The pattern for LONGCALL4. Support for function cse.
10651 sethi ta, hi20(symbol) ; LONGCALL4/HI20
10652 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10653 jral ta ; PTR_RES/EMPTY/INSN16 */
10654
10655 bfd_vma laddr;
10656 uint32_t insn;
10657 Elf_Internal_Rela *hi_irel, *ptr_irel, *insn_irel, *em_irel, *call_irel;
10658 Elf_Internal_Rela *irelend;
10659 bfd_signed_vma foff;
10660
10661 irelend = internal_relocs + sec->reloc_count;
10662 laddr = irel->r_offset;
10663
10664 /* Get the reloc for the address from which the register is
10665 being loaded. This reloc will tell us which function is
10666 actually being called. */
10667 hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10668 R_NDS32_HI20_RELA, laddr);
10669
10670 if (hi_irel == irelend)
10671 {
10672 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL4",
10673 (uint64_t) irel->r_offset);
10674 return FALSE;
10675 }
10676
10677 /* Get the value of the symbol referred to by the reloc. */
10678 foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr);
10679
10680 /* This condition only happened when symbol is undefined. */
10681 if (foff == 0
10682 || foff < -CONSERVATIVE_24BIT_S1
10683 || foff >= CONSERVATIVE_24BIT_S1)
10684 return FALSE;
10685
10686 /* Relax to: jal symbol; 25_PCREL. */
10687 /* For simplicity of coding, we are going to modify the section
10688 contents, the section relocs, and the BFD symbol table. We
10689 must tell the rest of the code not to free up this
10690 information. It would be possible to instead create a table
10691 of changes which have to be made, as is done in coff-mips.c;
10692 that would be more work, but would require less memory when
10693 the linker is run. */
10694
10695 ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10696 R_NDS32_PTR_RESOLVED, irel->r_addend);
10697 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10698 R_NDS32_EMPTY, irel->r_addend);
10699
10700 if (ptr_irel == irelend || em_irel == irelend)
10701 {
10702 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL4",
10703 (uint64_t) irel->r_offset);
10704 return FALSE;
10705 }
10706 /* Check these is enough space to insert jal in R_NDS32_EMPTY. */
10707 insn = bfd_getb32 (contents + irel->r_addend);
10708 if (insn & 0x80000000)
10709 return FALSE;
10710
10711 /* Replace the long call with a jal. */
10712 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10713 R_NDS32_25_PCREL_RELA);
10714 ptr_irel->r_addend = 1;
10715
10716 /* We don't resolve this here but resolve it in relocate_section. */
10717 insn = INSN_JAL;
10718 bfd_putb32 (insn, contents + em_irel->r_offset);
10719
10720 irel->r_info =
10721 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10722
10723 /* If there is function cse, HI20 can not remove now. */
10724 call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10725 R_NDS32_LONGCALL4, laddr);
10726 if (call_irel == irelend)
10727 {
10728 *insn_len = 0;
10729 hi_irel->r_info =
10730 ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10731 }
10732
10733 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10734 R_NDS32_INSN16, irel->r_addend);
10735 if (insn_irel != irelend)
10736 insn_irel->r_info =
10737 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10738
10739 return TRUE;
10740 }
10741
10742 /* Relax LONGCALL5 relocation for nds32_elf_relax_section. */
10743
10744 static bfd_boolean
10745 nds32_elf_relax_longcall5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10746 Elf_Internal_Rela *internal_relocs, int *insn_len,
10747 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10748 Elf_Internal_Shdr *symtab_hdr)
10749 {
10750 /* The pattern for LONGCALL5.
10751 bltz rt, .L1 ; LONGCALL5/17_PCREL
10752 jal symbol ; 25_PCREL
10753 .L1: */
10754
10755 bfd_vma laddr;
10756 uint32_t insn;
10757 Elf_Internal_Rela *cond_irel, *irelend;
10758 bfd_signed_vma foff;
10759
10760 irelend = internal_relocs + sec->reloc_count;
10761 laddr = irel->r_offset;
10762 insn = bfd_getb32 (contents + laddr);
10763
10764 /* Get the reloc for the address from which the register is
10765 being loaded. This reloc will tell us which function is
10766 actually being called. */
10767 cond_irel =
10768 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10769 R_NDS32_25_PCREL_RELA, irel->r_addend);
10770 if (cond_irel == irelend)
10771 {
10772 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL5",
10773 (uint64_t) irel->r_offset);
10774 return FALSE;
10775 }
10776
10777 /* Get the value of the symbol referred to by the reloc. */
10778 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr);
10779
10780 if (foff == 0
10781 || foff < -CONSERVATIVE_16BIT_S1
10782 || foff >= CONSERVATIVE_16BIT_S1)
10783 return FALSE;
10784
10785 /* Relax to bgezal rt, label ; 17_PCREL
10786 or bltzal rt, label ; 17_PCREL. */
10787
10788 /* Convert to complimentary conditional call. */
10789 insn = CONVERT_CONDITION_CALL (insn);
10790
10791 /* For simplicity of coding, we are going to modify the section
10792 contents, the section relocs, and the BFD symbol table. We
10793 must tell the rest of the code not to free up this
10794 information. It would be possible to instead create a table
10795 of changes which have to be made, as is done in coff-mips.c;
10796 that would be more work, but would require less memory when
10797 the linker is run. */
10798
10799 /* Modify relocation and contents. */
10800 cond_irel->r_info =
10801 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_17_PCREL_RELA);
10802
10803 /* Replace the long call with a bgezal. */
10804 bfd_putb32 (insn, contents + cond_irel->r_offset);
10805 *insn_len = 0;
10806
10807 /* Clean unnessary relocations. */
10808 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10809
10810 cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10811 R_NDS32_17_PCREL_RELA, laddr);
10812 cond_irel->r_info =
10813 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10814
10815 return TRUE;
10816 }
10817
10818 /* Relax LONGCALL6 relocation for nds32_elf_relax_section. */
10819
10820 static bfd_boolean
10821 nds32_elf_relax_longcall6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10822 Elf_Internal_Rela *internal_relocs, int *insn_len,
10823 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10824 Elf_Internal_Shdr *symtab_hdr)
10825 {
10826 /* The pattern for LONGCALL6.
10827 bltz rt, .L1 ; LONGCALL6/17_PCREL
10828 sethi ta, hi20(symbol) ; HI20/PTR
10829 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10830 jral ta ; PTR_RES/EMPTY/INSN16
10831 .L1 */
10832
10833 bfd_vma laddr;
10834 uint32_t insn;
10835 Elf_Internal_Rela *em_irel, *cond_irel, *irelend;
10836 bfd_signed_vma foff;
10837
10838 irelend = internal_relocs + sec->reloc_count;
10839 laddr = irel->r_offset;
10840
10841 /* Get the reloc for the address from which the register is
10842 being loaded. This reloc will tell us which function is
10843 actually being called. */
10844 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10845 R_NDS32_EMPTY, irel->r_addend);
10846
10847 if (em_irel == irelend)
10848 {
10849 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGCALL6",
10850 (uint64_t) irel->r_offset);
10851 return FALSE;
10852 }
10853
10854 /* Get the value of the symbol referred to by the reloc. */
10855 foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr);
10856
10857 if (foff == 0
10858 || foff < -CONSERVATIVE_24BIT_S1
10859 || foff >= CONSERVATIVE_24BIT_S1)
10860 return FALSE;
10861
10862 /* Check these is enough space to insert jal in R_NDS32_EMPTY. */
10863 insn = bfd_getb32 (contents + irel->r_addend);
10864 if (insn & 0x80000000)
10865 return FALSE;
10866
10867 insn = bfd_getb32 (contents + laddr);
10868 if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10869 {
10870 /* Relax to bgezal rt, label ; 17_PCREL
10871 or bltzal rt, label ; 17_PCREL. */
10872
10873 /* Convert to complimentary conditional call. */
10874 *insn_len = 0;
10875 insn = CONVERT_CONDITION_CALL (insn);
10876 bfd_putb32 (insn, contents + em_irel->r_offset);
10877
10878 em_irel->r_info =
10879 ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_17_PCREL_RELA);
10880
10881 /* Set resolved relocation. */
10882 cond_irel =
10883 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10884 R_NDS32_PTR_RESOLVED, irel->r_addend);
10885 if (cond_irel == irelend)
10886 {
10887 _bfd_error_handler (unrecognized_reloc_msg, abfd,
10888 "R_NDS32_LONGCALL6", (uint64_t) irel->r_offset);
10889 return FALSE;
10890 }
10891 cond_irel->r_addend = 1;
10892
10893 /* Clear relocations. */
10894
10895 irel->r_info =
10896 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10897
10898 cond_irel =
10899 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10900 R_NDS32_17_PCREL_RELA, laddr);
10901 if (cond_irel != irelend)
10902 cond_irel->r_info =
10903 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10904
10905 cond_irel =
10906 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10907 R_NDS32_INSN16, irel->r_addend);
10908 if (cond_irel != irelend)
10909 cond_irel->r_info =
10910 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10911
10912 }
10913 else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
10914 {
10915 /* Relax to the following instruction sequence
10916 bltz rt, .L1 ; LONGCALL2/17_PCREL
10917 jal symbol ; 25_PCREL/PTR_RES
10918 .L1 */
10919 *insn_len = 4;
10920 /* Convert instruction. */
10921 insn = INSN_JAL;
10922 bfd_putb32 (insn, contents + em_irel->r_offset);
10923
10924 /* Convert relocations. */
10925 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10926 R_NDS32_25_PCREL_RELA);
10927 irel->r_info =
10928 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL5);
10929
10930 /* Set resolved relocation. */
10931 cond_irel =
10932 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10933 R_NDS32_PTR_RESOLVED, irel->r_addend);
10934 if (cond_irel == irelend)
10935 {
10936 _bfd_error_handler (unrecognized_reloc_msg, abfd,
10937 "R_NDS32_LONGCALL6", (uint64_t) irel->r_offset);
10938 return FALSE;
10939 }
10940 cond_irel->r_addend = 1;
10941
10942 cond_irel =
10943 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10944 R_NDS32_INSN16, irel->r_addend);
10945 if (cond_irel != irelend)
10946 cond_irel->r_info =
10947 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10948 }
10949 return TRUE;
10950 }
10951
10952 /* Relax LONGJUMP4 relocation for nds32_elf_relax_section. */
10953
10954 static bfd_boolean
10955 nds32_elf_relax_longjump4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10956 Elf_Internal_Rela *internal_relocs, int *insn_len,
10957 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10958 Elf_Internal_Shdr *symtab_hdr)
10959 {
10960 /* The pattern for LONGJUMP4.
10961 sethi ta, hi20(symbol) ; LONGJUMP4/HI20
10962 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10963 jr ta ; PTR_RES/INSN16/EMPTY */
10964
10965 bfd_vma laddr;
10966 int seq_len; /* Original length of instruction sequence. */
10967 uint32_t insn;
10968 Elf_Internal_Rela *hi_irel, *ptr_irel, *em_irel, *call_irel, *irelend;
10969 bfd_signed_vma foff;
10970
10971 irelend = internal_relocs + sec->reloc_count;
10972 seq_len = GET_SEQ_LEN (irel->r_addend);
10973 laddr = irel->r_offset;
10974 *insn_len = seq_len;
10975
10976 /* Get the reloc for the address from which the register is
10977 being loaded. This reloc will tell us which function is
10978 actually being called. */
10979
10980 hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10981 R_NDS32_HI20_RELA, laddr);
10982
10983 if (hi_irel == irelend)
10984 {
10985 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP4",
10986 (uint64_t) irel->r_offset);
10987 return FALSE;
10988 }
10989
10990 /* Get the value of the symbol referred to by the reloc. */
10991 foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr);
10992
10993 if (foff == 0
10994 || foff >= CONSERVATIVE_24BIT_S1
10995 || foff < -CONSERVATIVE_24BIT_S1)
10996 return FALSE;
10997
10998 /* Convert it to "j label", it may be converted to j8 in the final
10999 pass of relaxation. Therefore, we do not consider this currently. */
11000 ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11001 R_NDS32_PTR_RESOLVED, irel->r_addend);
11002 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11003 R_NDS32_EMPTY, irel->r_addend);
11004
11005 if (ptr_irel == irelend || em_irel == irelend)
11006 {
11007 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP4",
11008 (uint64_t) irel->r_offset);
11009 return FALSE;
11010 }
11011
11012 em_irel->r_info =
11013 ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_25_PCREL_RELA);
11014 ptr_irel->r_addend = 1;
11015
11016 /* Write instruction. */
11017 insn = INSN_J;
11018 bfd_putb32 (insn, contents + em_irel->r_offset);
11019
11020 /* Clear relocations. */
11021 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11022
11023 /* If there is function cse, HI20 can not remove now. */
11024 call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11025 R_NDS32_LONGJUMP4, laddr);
11026 if (call_irel == irelend)
11027 {
11028 *insn_len = 0;
11029 hi_irel->r_info =
11030 ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
11031 }
11032
11033 return TRUE;
11034 }
11035
11036 /* Relax LONGJUMP5 relocation for nds32_elf_relax_section. */
11037
11038 static bfd_boolean
11039 nds32_elf_relax_longjump5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11040 Elf_Internal_Rela *internal_relocs, int *insn_len,
11041 int *seq_len, bfd_byte *contents,
11042 Elf_Internal_Sym *isymbuf,
11043 Elf_Internal_Shdr *symtab_hdr)
11044 {
11045 /* There are 2 variations for LONGJUMP5
11046 case 2-4; 1st insn convertible, 16-bit on.
11047 bnes38 rt, ra, .L1 ; LONGJUMP5/9_PCREL/INSN16
11048 j label ; 25_PCREL/INSN16
11049 $1:
11050
11051 case 4-4; 1st insn not convertible
11052 bne rt, ra, .L1 ; LONGJUMP5/15_PCREL/INSN16
11053 j label ; 25_PCREL/INSN16
11054 .L1: */
11055
11056 bfd_vma laddr;
11057 Elf_Internal_Rela *cond_irel, *irelend;
11058 unsigned int i;
11059 bfd_signed_vma foff;
11060 uint32_t insn, re_insn = 0;
11061 uint16_t insn16, re_insn16 = 0;
11062 unsigned long reloc;
11063
11064 enum elf_nds32_reloc_type checked_types[] =
11065 { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
11066 R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
11067
11068 irelend = internal_relocs + sec->reloc_count;
11069 laddr = irel->r_offset;
11070
11071 /* Get the reloc for the address from which the register is
11072 being loaded. This reloc will tell us which function is
11073 actually being called. */
11074
11075 cond_irel =
11076 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11077 R_NDS32_25_PCREL_RELA, irel->r_addend);
11078 if (cond_irel == irelend)
11079 {
11080 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP5",
11081 (uint64_t) irel->r_offset);
11082 return FALSE;
11083 }
11084
11085 /* Get the value of the symbol referred to by the reloc. */
11086 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr);
11087
11088 if (foff == 0
11089 || foff < -CONSERVATIVE_16BIT_S1
11090 || foff >= CONSERVATIVE_16BIT_S1)
11091 return FALSE;
11092
11093 /* Get the all corresponding instructions. */
11094 insn = bfd_getb32 (contents + laddr);
11095 /* Check instruction size. */
11096 if (insn & 0x80000000)
11097 {
11098 *seq_len = 0;
11099 insn16 = insn >> 16;
11100 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
11101 }
11102 else
11103 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
11104
11105 if (N32_OP6 (re_insn) == N32_OP6_BR1
11106 && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
11107 {
11108 /* beqs label ; 15_PCREL. */
11109 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11110 reloc = R_NDS32_15_PCREL_RELA;
11111 }
11112 else if (N32_OP6 (re_insn) == N32_OP6_BR2
11113 && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
11114 {
11115 /* beqz label ; 17_PCREL. */
11116 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11117 reloc = R_NDS32_17_PCREL_RELA;
11118 }
11119 else if ( N32_OP6 (re_insn) == N32_OP6_BR3
11120 && foff >= -CONSERVATIVE_8BIT_S1 && foff < CONSERVATIVE_8BIT_S1)
11121 {
11122 /* beqc label ; 9_PCREL. */
11123 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11124 reloc = R_NDS32_WORD_9_PCREL_RELA;
11125 }
11126 else
11127 return FALSE;
11128
11129 /* Set all relocations. */
11130 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), reloc);
11131
11132 /* Clean relocations. */
11133 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11134 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
11135 {
11136 cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11137 checked_types[i], laddr);
11138 if (cond_irel != irelend)
11139 {
11140 if (*seq_len == 0
11141 && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
11142 {
11143 /* If the branch instruction is 2 byte, it cannot remove
11144 directly. Only convert it to nop16 and remove it after
11145 checking alignment issue. */
11146 insn16 = NDS32_NOP16;
11147 bfd_putb16 (insn16, contents + laddr);
11148 cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
11149 }
11150 else
11151 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11152 R_NDS32_NONE);
11153 }
11154 }
11155 *insn_len = 0;
11156
11157 return TRUE;
11158 }
11159
11160 /* Relax LONGJUMP6 relocation for nds32_elf_relax_section. */
11161
11162 static bfd_boolean
11163 nds32_elf_relax_longjump6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11164 Elf_Internal_Rela *internal_relocs, int *insn_len,
11165 int *seq_len, bfd_byte *contents,
11166 Elf_Internal_Sym *isymbuf,
11167 Elf_Internal_Shdr *symtab_hdr)
11168 {
11169 /* There are 5 variations for LONGJUMP6
11170 case : 2-4-4-4; 1st insn convertible, 16-bit on.
11171 bnes38 rt, ra, .L1 ; LONGJUMP6/15_PCREL/INSN16
11172 sethi ta, hi20(symbol) ; HI20/PTR
11173 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
11174 jr ta ; PTR_RES/INSN16/EMPTY
11175 .L1:
11176
11177 case : 4-4-4-4; 1st insn not convertible, 16-bit on.
11178 bne rt, ra, .L1 ; LONGJUMP6/15_PCREL/INSN16
11179 sethi ta, hi20(symbol) ; HI20/PTR
11180 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
11181 jr ta ; PTR_RES/INSN16/EMPTY
11182 .L1: */
11183
11184 enum elf_nds32_reloc_type checked_types[] =
11185 { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
11186 R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
11187
11188 int reloc_off = 0, cond_removed = 0;
11189 bfd_vma laddr;
11190 Elf_Internal_Rela *cond_irel, *em_irel, *irelend, *insn_irel;
11191 unsigned int i;
11192 bfd_signed_vma foff;
11193 uint32_t insn, re_insn = 0;
11194 uint16_t insn16, re_insn16 = 0;
11195 unsigned long reloc;
11196
11197 irelend = internal_relocs + sec->reloc_count;
11198 laddr = irel->r_offset;
11199
11200 /* Get the reloc for the address from which the register is
11201 being loaded. This reloc will tell us which function is
11202 actually being called. */
11203 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11204 R_NDS32_EMPTY, irel->r_addend);
11205
11206 if (em_irel == irelend)
11207 {
11208 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP6",
11209 (uint64_t) irel->r_offset);
11210 return FALSE;
11211 }
11212
11213 /* Get the value of the symbol referred to by the reloc. */
11214 foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr);
11215
11216 if (foff == 0
11217 || foff < -CONSERVATIVE_24BIT_S1
11218 || foff >= CONSERVATIVE_24BIT_S1)
11219 return FALSE;
11220
11221 insn = bfd_getb32 (contents + laddr);
11222 /* Check instruction size. */
11223 if (insn & 0x80000000)
11224 {
11225 *seq_len = 0;
11226 insn16 = insn >> 16;
11227 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
11228 }
11229 else
11230 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
11231
11232 /* For simplicity of coding, we are going to modify the section
11233 contents, the section relocs, and the BFD symbol table. We
11234 must tell the rest of the code not to free up this
11235 information. It would be possible to instead create a table
11236 of changes which have to be made, as is done in coff-mips.c;
11237 that would be more work, but would require less memory when
11238 the linker is run. */
11239
11240 if (N32_OP6 (re_insn) == N32_OP6_BR1
11241 && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
11242 {
11243 /* beqs label ; 15_PCREL. */
11244 bfd_putb32 (re_insn, contents + em_irel->r_offset);
11245 reloc = R_NDS32_15_PCREL_RELA;
11246 cond_removed = 1;
11247 }
11248 else if (N32_OP6 (re_insn) == N32_OP6_BR2
11249 && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
11250 {
11251 /* beqz label ; 17_PCREL. */
11252 bfd_putb32 (re_insn, contents + em_irel->r_offset);
11253 reloc = R_NDS32_17_PCREL_RELA;
11254 cond_removed = 1;
11255 }
11256 else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
11257 && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
11258 {
11259 /* Relax to one of the following 2 variations
11260
11261 case 2-4; 1st insn convertible, 16-bit on.
11262 bnes38 rt, ra, .L1 ; LONGJUMP5/9_PCREL/INSN16
11263 j label ; 25_PCREL/INSN16
11264 $1:
11265
11266 case 4-4; 1st insn not convertible
11267 bne rt, ra, .L1 ; LONGJUMP5/15_PCREL/INSN16
11268 j label ; 25_PCREL/INSN16
11269 .L1: */
11270
11271 /* Use j label as second instruction. */
11272 insn = INSN_J;
11273 reloc = R_NDS32_25_PCREL_RELA;
11274 bfd_putb32 (insn, contents + em_irel->r_offset);
11275 }
11276 else
11277 return FALSE;
11278
11279 /* Set all relocations. */
11280 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), reloc);
11281
11282 cond_irel =
11283 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11284 R_NDS32_PTR_RESOLVED, em_irel->r_offset);
11285 cond_irel->r_addend = 1;
11286
11287 /* Use INSN16 of first branch instruction to distinguish if keeping
11288 INSN16 of final instruction or not. */
11289 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11290 R_NDS32_INSN16, irel->r_offset);
11291 if (insn_irel == irelend)
11292 {
11293 /* Clean the final INSN16. */
11294 insn_irel =
11295 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11296 R_NDS32_INSN16, em_irel->r_offset);
11297 insn_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11298 R_NDS32_NONE);
11299 }
11300
11301 if (cond_removed == 1)
11302 {
11303 *insn_len = 0;
11304
11305 /* Clear relocations. */
11306 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11307
11308 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
11309 {
11310 cond_irel =
11311 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11312 checked_types[i], laddr);
11313 if (cond_irel != irelend)
11314 {
11315 if (*seq_len == 0
11316 && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
11317 {
11318 /* If the branch instruction is 2 byte, it cannot remove
11319 directly. Only convert it to nop16 and remove it after
11320 checking alignment issue. */
11321 insn16 = NDS32_NOP16;
11322 bfd_putb16 (insn16, contents + laddr);
11323 cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
11324 }
11325 else
11326 cond_irel->r_info =
11327 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
11328 }
11329 }
11330 }
11331 else
11332 {
11333 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11334 R_NDS32_LONGJUMP5);
11335 }
11336
11337 return TRUE;
11338 }
11339
11340 /* Relax LONGJUMP7 relocation for nds32_elf_relax_section. */
11341
11342 static bfd_boolean
11343 nds32_elf_relax_longjump7 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11344 Elf_Internal_Rela *internal_relocs, int *insn_len,
11345 int *seq_len, bfd_byte *contents,
11346 Elf_Internal_Sym *isymbuf,
11347 Elf_Internal_Shdr *symtab_hdr)
11348 {
11349 /* There are 2 variations for LONGJUMP5
11350 case 2-4; 1st insn convertible, 16-bit on.
11351 movi55 ta, imm11 ; LONGJUMP7/INSN16
11352 beq rt, ta, label ; 15_PCREL
11353
11354 case 4-4; 1st insn not convertible
11355 movi55 ta, imm11 ; LONGJUMP7/INSN16
11356 beq rt, ta, label ; 15_PCREL */
11357
11358 bfd_vma laddr;
11359 Elf_Internal_Rela *cond_irel, *irelend, *insn_irel;
11360 bfd_signed_vma foff;
11361 uint32_t insn, re_insn = 0;
11362 uint16_t insn16;
11363 uint32_t imm11;
11364
11365 irelend = internal_relocs + sec->reloc_count;
11366 laddr = irel->r_offset;
11367
11368 /* Get the reloc for the address from which the register is
11369 being loaded. This reloc will tell us which function is
11370 actually being called. */
11371
11372 cond_irel =
11373 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11374 R_NDS32_15_PCREL_RELA, irel->r_addend);
11375 if (cond_irel == irelend)
11376 {
11377 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LONGJUMP7",
11378 (uint64_t) irel->r_offset);
11379 return FALSE;
11380 }
11381
11382 /* Get the value of the symbol referred to by the reloc. */
11383 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr);
11384
11385 if (foff == 0
11386 || foff < -CONSERVATIVE_8BIT_S1
11387 || foff >= CONSERVATIVE_8BIT_S1)
11388 return FALSE;
11389
11390 /* Get the first instruction for its size. */
11391 insn = bfd_getb32 (contents + laddr);
11392 if (insn & 0x80000000)
11393 {
11394 *seq_len = 0;
11395 /* Get the immediate from movi55. */
11396 imm11 = N16_IMM5S (insn >> 16);
11397 }
11398 else
11399 {
11400 /* Get the immediate from movi. */
11401 imm11 = N32_IMM20S (insn);
11402 }
11403
11404 /* Get the branch instruction. */
11405 insn = bfd_getb32 (contents + irel->r_addend);
11406 /* Convert instruction to BR3. */
11407 if ((insn >> 14) & 0x1)
11408 re_insn = N32_BR3 (BNEC, N32_RT5 (insn), imm11, 0);
11409 else
11410 re_insn = N32_BR3 (BEQC, N32_RT5 (insn), imm11, 0);
11411
11412 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
11413
11414 /* Set all relocations. */
11415 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11416 R_NDS32_WORD_9_PCREL_RELA);
11417
11418 /* Clean relocations. */
11419 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11420 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11421 R_NDS32_INSN16, irel->r_offset);
11422 if (insn_irel != irelend)
11423 {
11424 if (*seq_len == 0)
11425 {
11426 /* If the first insntruction is 16bit, convert it to nop16. */
11427 insn16 = NDS32_NOP16;
11428 bfd_putb16 (insn16, contents + laddr);
11429 insn_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
11430 }
11431 else
11432 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
11433 R_NDS32_NONE);
11434 }
11435 *insn_len = 0;
11436
11437 return TRUE;
11438 }
11439
11440 /* We figure out and reassign the best gp value in nds32_elf_final_sda_base
11441 for each relax round. But the gp may changed dramatically and then cause
11442 the truncated to fit errors for the the converted gp instructions.
11443 Therefore, we must reserve the minimum but safe enough size to prevent it. */
11444
11445 static bfd_boolean
11446 nds32_elf_relax_guard (bfd_vma *access_addr, bfd_vma local_sda, asection *sec,
11447 Elf_Internal_Rela *irel, bfd_boolean *again,
11448 bfd_boolean init,
11449 struct elf_nds32_link_hash_table *table,
11450 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr)
11451
11452 {
11453 int offset_to_gp;
11454 static bfd_boolean sec_pass = FALSE;
11455 static asection *first_sec = NULL, *sym_sec;
11456 /* Record the number of instructions which may be removed. */
11457 static int count = 0, record_count;
11458 Elf_Internal_Sym *isym;
11459 struct elf_link_hash_entry *h = NULL;
11460 int indx;
11461 unsigned long r_symndx;
11462 bfd *abfd = sec->owner;
11463 static bfd_vma record_sda = 0;
11464 int sda_offset = 0;
11465
11466 /* Force doing relaxation when hyper-relax is high. */
11467 if (table->hyper_relax == 2)
11468 return TRUE;
11469
11470 /* Do not relax the load/store patterns for the first
11471 relax round. */
11472 if (init)
11473 {
11474 if (!first_sec)
11475 first_sec = sec;
11476 else if (first_sec == sec)
11477 {
11478 record_count = count;
11479 count = 0;
11480 sec_pass = TRUE;
11481 }
11482
11483 if (!sec_pass)
11484 *again = TRUE;
11485
11486 return TRUE;
11487 }
11488
11489 /* Generally, _SDA_BASE_ is fixed or smaller. But the large
11490 DATA_SEGMENT_ALIGN size in the linker script may make it
11491 get even bigger. */
11492 if (record_sda == 0)
11493 record_sda = local_sda;
11494 else if (local_sda > record_sda)
11495 sda_offset = local_sda - record_sda;
11496
11497 /* Assume the instruction will be removed in the best case. */
11498 count++;
11499
11500 /* We record the offset to gp for each symbol, and then check
11501 if it is changed dramatically after relaxing.
11502 (global symbol): elf32_nds32_hash_entry (h)->offset_to_gp
11503 (local symbol) : elf32_nds32_local_gp_offset (abfd)[r_symndx]. */
11504 r_symndx = ELF32_R_SYM (irel->r_info);
11505 if (r_symndx >= symtab_hdr->sh_info)
11506 {
11507 /* Global symbols. */
11508 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
11509 h = elf_sym_hashes (abfd)[indx];
11510 sym_sec = h->root.u.def.section;
11511 if (NDS32_GUARD_SEC_P (sym_sec->flags)
11512 || bfd_is_abs_section (sym_sec))
11513 {
11514 /* Forbid doing relaxation when hyper-relax is low. */
11515 if (table->hyper_relax == 0)
11516 return FALSE;
11517
11518 offset_to_gp = *access_addr - local_sda;
11519 if (elf32_nds32_hash_entry (h)->offset_to_gp == 0)
11520 elf32_nds32_hash_entry (h)->offset_to_gp = offset_to_gp;
11521 else if (abs (elf32_nds32_hash_entry (h)->offset_to_gp)
11522 < abs (offset_to_gp) - sda_offset)
11523 {
11524 /* This may cause the error, so we reserve the
11525 safe enough size for relaxing. */
11526 if (*access_addr >= local_sda)
11527 *access_addr += (record_count * 4);
11528 else
11529 *access_addr -= (record_count * 4);
11530 }
11531 return sec_pass;
11532 }
11533 }
11534 else
11535 {
11536 /* Local symbols. */
11537 if (!elf32_nds32_allocate_local_sym_info (abfd))
11538 return FALSE;
11539 isym = isymbuf + r_symndx;
11540
11541 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
11542 if (NDS32_GUARD_SEC_P (sym_sec->flags))
11543 {
11544 /* Forbid doing relaxation when hyper-relax is low. */
11545 if (table->hyper_relax == 0)
11546 return FALSE;
11547
11548 offset_to_gp = *access_addr - local_sda;
11549 if (elf32_nds32_local_gp_offset (abfd)[r_symndx] == 0)
11550 elf32_nds32_local_gp_offset (abfd)[r_symndx] = offset_to_gp;
11551 else if (abs (elf32_nds32_local_gp_offset (abfd)[r_symndx])
11552 < abs (offset_to_gp) - sda_offset)
11553 {
11554 /* This may cause the error, so we reserve the
11555 safe enough size for relaxing. */
11556 if (*access_addr >= local_sda)
11557 *access_addr += (record_count * 4);
11558 else
11559 *access_addr -= (record_count * 4);
11560 }
11561 return sec_pass;
11562 }
11563 }
11564
11565 return TRUE;
11566 }
11567
11568 #define GET_LOADSTORE_RANGE(addend) (((addend) >> 8) & 0x3f)
11569
11570 /* Relax LOADSTORE relocation for nds32_elf_relax_section. */
11571
11572 static bfd_boolean
11573 nds32_elf_relax_loadstore (struct bfd_link_info *link_info, bfd *abfd,
11574 asection *sec, Elf_Internal_Rela *irel,
11575 Elf_Internal_Rela *internal_relocs, int *insn_len,
11576 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11577 Elf_Internal_Shdr *symtab_hdr, int load_store_relax,
11578 struct elf_nds32_link_hash_table *table)
11579 {
11580 int eliminate_sethi = 0, range_type;
11581 unsigned int i;
11582 bfd_vma local_sda, laddr;
11583 int seq_len; /* Original length of instruction sequence. */
11584 uint32_t insn;
11585 Elf_Internal_Rela *hi_irelfn = NULL, *irelend;
11586 bfd_vma access_addr = 0;
11587 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
11588 struct elf_link_hash_entry *h = NULL;
11589 int indx;
11590 enum elf_nds32_reloc_type checked_types[] =
11591 { R_NDS32_HI20_RELA, R_NDS32_GOT_HI20,
11592 R_NDS32_GOTPC_HI20, R_NDS32_GOTOFF_HI20,
11593 R_NDS32_PLTREL_HI20, R_NDS32_PLT_GOTREL_HI20,
11594 R_NDS32_TLS_LE_HI20
11595 };
11596
11597 irelend = internal_relocs + sec->reloc_count;
11598 seq_len = GET_SEQ_LEN (irel->r_addend);
11599 laddr = irel->r_offset;
11600 *insn_len = seq_len;
11601
11602 /* Get the high part relocation. */
11603 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
11604 {
11605 hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
11606 checked_types[i], laddr);
11607 if (hi_irelfn != irelend)
11608 break;
11609 }
11610
11611 if (hi_irelfn == irelend)
11612 {
11613 /* Not R_NDS32_HI20_RELA. */
11614 if (i != 0)
11615 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LOADSTORE",
11616 (uint64_t) irel->r_offset);
11617 return FALSE;
11618 }
11619
11620 range_type = GET_LOADSTORE_RANGE (irel->r_addend);
11621 nds32_elf_final_sda_base (sec->output_section->owner,
11622 link_info, &local_sda, FALSE);
11623
11624 switch (ELF32_R_TYPE (hi_irelfn->r_info))
11625 {
11626 case R_NDS32_HI20_RELA:
11627 insn = bfd_getb32 (contents + laddr);
11628 access_addr =
11629 calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
11630
11631 if (ELF32_R_SYM (hi_irelfn->r_info) >= symtab_hdr->sh_info)
11632 {
11633 indx = ELF32_R_SYM (hi_irelfn->r_info) - symtab_hdr->sh_info;
11634 h = elf_sym_hashes (abfd)[indx];
11635 }
11636
11637 /* Try movi. */
11638 if (range_type == NDS32_LOADSTORE_IMM
11639 && access_addr < CONSERVATIVE_20BIT
11640 && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
11641 {
11642 eliminate_sethi = 1;
11643 break;
11644 }
11645
11646 if (h && strcmp (h->root.root.string, FP_BASE_NAME) == 0)
11647 {
11648 eliminate_sethi = 1;
11649 break;
11650 }
11651 else if (!nds32_elf_relax_guard (&access_addr, local_sda, sec, hi_irelfn,
11652 NULL, FALSE, table, isymbuf, symtab_hdr))
11653 return FALSE;
11654
11655 if (!load_store_relax)
11656 return FALSE;
11657
11658 /* Case for set gp register. */
11659 if (N32_RT5 (insn) == REG_GP)
11660 return FALSE;
11661
11662 if (range_type == NDS32_LOADSTORE_FLOAT_S
11663 || range_type == NDS32_LOADSTORE_FLOAT_D)
11664 {
11665 range_l = sdata_range[0][0];
11666 range_h = sdata_range[0][1];
11667 }
11668 else
11669 {
11670 range_l = sdata_range[1][0];
11671 range_h = sdata_range[1][1];
11672 }
11673 break;
11674
11675 default:
11676 return FALSE;
11677 }
11678
11679 /* Delete sethi instruction. */
11680 if (eliminate_sethi == 1
11681 || (local_sda <= access_addr && (access_addr - local_sda) < range_h)
11682 || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
11683 {
11684 hi_irelfn->r_info =
11685 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
11686 irel->r_info =
11687 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11688 *insn_len = 0;
11689 return TRUE;
11690 }
11691
11692 return FALSE;
11693 }
11694
11695 /* Relax LO12 relocation for nds32_elf_relax_section. */
11696
11697 static void
11698 nds32_elf_relax_lo12 (struct bfd_link_info *link_info, bfd *abfd,
11699 asection *sec, Elf_Internal_Rela *irel,
11700 Elf_Internal_Rela *internal_relocs, bfd_byte *contents,
11701 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr,
11702 struct elf_nds32_link_hash_table *table)
11703 {
11704 uint32_t insn;
11705 bfd_vma local_sda, laddr;
11706 unsigned long reloc;
11707 bfd_vma access_addr;
11708 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
11709 Elf_Internal_Rela *irelfn = NULL, *irelend;
11710 struct elf_link_hash_entry *h = NULL;
11711 int indx;
11712
11713 /* For SDA base relative relaxation. */
11714 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11715 &local_sda, FALSE);
11716
11717 irelend = internal_relocs + sec->reloc_count;
11718 laddr = irel->r_offset;
11719 insn = bfd_getb32 (contents + laddr);
11720
11721 if (!is_sda_access_insn (insn) && N32_OP6 (insn) != N32_OP6_ORI)
11722 return;
11723
11724 access_addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11725
11726 if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
11727 {
11728 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
11729 h = elf_sym_hashes (abfd)[indx];
11730 }
11731
11732 /* Try movi. */
11733 if (N32_OP6 (insn) == N32_OP6_ORI && access_addr < CONSERVATIVE_20BIT
11734 && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
11735 {
11736 reloc = R_NDS32_20_RELA;
11737 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11738 insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
11739 bfd_putb32 (insn, contents + laddr);
11740 }
11741 else
11742 {
11743 if (h && strcmp (h->root.root.string, FP_BASE_NAME) == 0)
11744 {
11745 /* Fall through. */
11746 }
11747 else if (!nds32_elf_relax_guard (&access_addr, local_sda, sec, irel, NULL,
11748 FALSE, table, isymbuf, symtab_hdr))
11749 return;
11750
11751 range_l = sdata_range[1][0];
11752 range_h = sdata_range[1][1];
11753 switch (ELF32_R_TYPE (irel->r_info))
11754 {
11755 case R_NDS32_LO12S0_RELA:
11756 reloc = R_NDS32_SDA19S0_RELA;
11757 break;
11758 case R_NDS32_LO12S1_RELA:
11759 reloc = R_NDS32_SDA18S1_RELA;
11760 break;
11761 case R_NDS32_LO12S2_RELA:
11762 reloc = R_NDS32_SDA17S2_RELA;
11763 break;
11764 case R_NDS32_LO12S2_DP_RELA:
11765 range_l = sdata_range[0][0];
11766 range_h = sdata_range[0][1];
11767 reloc = R_NDS32_SDA12S2_DP_RELA;
11768 break;
11769 case R_NDS32_LO12S2_SP_RELA:
11770 range_l = sdata_range[0][0];
11771 range_h = sdata_range[0][1];
11772 reloc = R_NDS32_SDA12S2_SP_RELA;
11773 break;
11774 default:
11775 return;
11776 }
11777
11778 /* There are range_h and range_l because linker has to promise
11779 all sections move cross one page together. */
11780 if ((local_sda <= access_addr && (access_addr - local_sda) < range_h)
11781 || (local_sda > access_addr && (local_sda - access_addr) <= range_l)
11782 || (h && strcmp (h->root.root.string, FP_BASE_NAME) == 0))
11783 {
11784 if (N32_OP6 (insn) == N32_OP6_ORI && N32_RT5 (insn) == REG_GP)
11785 {
11786 /* Maybe we should add R_NDS32_INSN16 reloc type here
11787 or manually do some optimization. sethi can't be
11788 eliminated when updating $gp so the relative ori
11789 needs to be preserved. */
11790 return;
11791 }
11792 if (!turn_insn_to_sda_access (insn, ELF32_R_TYPE (irel->r_info),
11793 &insn))
11794 return;
11795 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11796 bfd_putb32 (insn, contents + laddr);
11797
11798 irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11799 R_NDS32_INSN16);
11800 /* SDA17 must keep INSN16 for converting fp_as_gp. */
11801 if (irelfn != irelend && reloc != R_NDS32_SDA17S2_RELA)
11802 irelfn->r_info =
11803 ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_NDS32_NONE);
11804
11805 }
11806 }
11807 return;
11808 }
11809
11810 /* Relax PTR relocation for nds32_elf_relax_section. */
11811
11812 static bfd_boolean
11813 nds32_elf_relax_ptr (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11814 Elf_Internal_Rela *internal_relocs, int *insn_len,
11815 int *seq_len, bfd_byte *contents)
11816 {
11817 Elf_Internal_Rela *ptr_irel, *irelend, *count_irel, *re_irel;
11818
11819 irelend = internal_relocs + sec->reloc_count;
11820
11821 re_irel =
11822 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11823 R_NDS32_PTR_RESOLVED, irel->r_addend);
11824
11825 if (re_irel == irelend)
11826 {
11827 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_PTR",
11828 (uint64_t) irel->r_offset);
11829 return FALSE;
11830 }
11831
11832 if (re_irel->r_addend != 1)
11833 return FALSE;
11834
11835 /* Pointed target is relaxed and no longer needs this void *,
11836 change the type to NONE. */
11837 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11838
11839 /* Find PTR_COUNT to decide remove it or not. If PTR_COUNT does
11840 not exist, it means only count 1 and remove it directly. */
11841 /* TODO: I hope we can obsolate R_NDS32_COUNT in the future. */
11842 count_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11843 R_NDS32_PTR_COUNT);
11844 ptr_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11845 R_NDS32_PTR);
11846 if (count_irel != irelend)
11847 {
11848 if (--count_irel->r_addend > 0)
11849 return FALSE;
11850 }
11851
11852 if (ptr_irel != irelend)
11853 return FALSE;
11854
11855 /* If the PTR_COUNT is already 0, remove current instruction. */
11856 *seq_len = nds32_elf_insn_size (abfd, contents, irel->r_offset);
11857 *insn_len = 0;
11858 return TRUE;
11859 }
11860
11861 /* Relax LWC relocation for nds32_elf_relax_section. */
11862
11863 static void
11864 nds32_elf_relax_flsi (struct bfd_link_info *link_info, bfd *abfd,
11865 asection *sec, Elf_Internal_Rela *irel,
11866 Elf_Internal_Rela *internal_relocs,
11867 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11868 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11869 {
11870 /* Pattern:
11871 sethi ra, hi20(symbol) ; HI20/LOADSTORE
11872 ori ra, ra, lo12(symbol) ; LO12S0/PTR/PTR/.../INSN16
11873 flsi fsa, [ra + offset1] ; LSI/PTR_RESOLVED/INSN16
11874 flsi fsb, [ra + offset2] ; LSI/PTR_RESOLVED/INSN16
11875 ... */
11876
11877 uint32_t insn;
11878 bfd_vma local_sda, laddr;
11879 unsigned long reloc;
11880 bfd_vma access_addr, flsi_offset;
11881 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
11882 Elf_Internal_Rela *irelend, *re_irel;
11883 unsigned int opcode;
11884
11885 irelend = internal_relocs + sec->reloc_count;
11886 laddr = irel->r_offset;
11887 insn = bfd_getb32 (contents + laddr);
11888
11889 if ((insn & 0x80000000) || !is_sda_access_insn (insn))
11890 return;
11891
11892 /* Can not do relaxation for bi format. */
11893 if ((insn & 0x1000))
11894 return;
11895
11896 /* Only deal with flsi, fssi, fldi, fsdi, so far. */
11897 opcode = N32_OP6 (insn);
11898 if ((opcode == N32_OP6_LWC) || (opcode == N32_OP6_SWC))
11899 reloc = R_NDS32_SDA12S2_SP_RELA;
11900 else if ((opcode == N32_OP6_LDC) || (opcode == N32_OP6_SDC))
11901 reloc = R_NDS32_SDA12S2_DP_RELA;
11902 else
11903 return;
11904
11905 re_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11906 R_NDS32_PTR_RESOLVED);
11907 if (re_irel == irelend)
11908 {
11909 _bfd_error_handler (unrecognized_reloc_msg, abfd, "R_NDS32_LSI",
11910 (uint64_t) irel->r_offset);
11911 return;
11912 }
11913
11914 /* For SDA base relative relaxation. */
11915 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11916 &local_sda, FALSE);
11917 access_addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11918 flsi_offset = (insn & 0xfff) << 2;
11919 access_addr += flsi_offset;
11920 range_l = sdata_range[0][0];
11921 range_h = sdata_range[0][1];
11922
11923 if ((local_sda <= access_addr && (access_addr - local_sda) < range_h)
11924 || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
11925 {
11926 /* Turn flsi instruction into sda access format. */
11927 insn = (insn & 0x7ff07000) | (REG_GP << 15);
11928
11929 /* Add relocation type to flsi. */
11930 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11931 irel->r_addend += flsi_offset;
11932 bfd_putb32 (insn, contents + re_irel->r_offset);
11933
11934 re_irel->r_addend |= 1;
11935 *again = TRUE;
11936 }
11937 }
11938
11939 static bfd_boolean
11940 nds32_relax_adjust_label (bfd *abfd, asection *sec,
11941 Elf_Internal_Rela *internal_relocs,
11942 bfd_byte *contents,
11943 nds32_elf_blank_t **relax_blank_list,
11944 int optimize, int opt_size)
11945 {
11946 /* This code block is used to adjust 4-byte alignment by relax a pair
11947 of instruction a time.
11948
11949 It recognizes three types of relocations.
11950 1. R_NDS32_LABEL - a alignment.
11951 2. R_NDS32_INSN16 - relax a 32-bit instruction to 16-bit.
11952 3. is_16bit_NOP () - remove a 16-bit instruction. */
11953
11954 /* TODO: It seems currently implementation only support 4-byte alignment.
11955 We should handle any-alignment. */
11956
11957 Elf_Internal_Rela *insn_rel = NULL, *label_rel = NULL, *irel;
11958 Elf_Internal_Rela *tmp_rel, *tmp2_rel = NULL;
11959 Elf_Internal_Rela rel_temp;
11960 Elf_Internal_Rela *irelend;
11961 bfd_vma address;
11962 uint16_t insn16;
11963
11964 /* Checking for branch relaxation relies on the relocations to
11965 be sorted on 'r_offset'. This is not guaranteed so we must sort. */
11966 nds32_insertion_sort (internal_relocs, sec->reloc_count,
11967 sizeof (Elf_Internal_Rela), compar_reloc);
11968
11969 irelend = internal_relocs + sec->reloc_count;
11970
11971 /* Force R_NDS32_LABEL before R_NDS32_INSN16. */
11972 /* FIXME: Can we generate the right order in assembler?
11973 So we don't have to swapping them here. */
11974
11975 for (label_rel = internal_relocs, insn_rel = internal_relocs;
11976 label_rel < irelend; label_rel++)
11977 {
11978 if (ELF32_R_TYPE (label_rel->r_info) != R_NDS32_LABEL)
11979 continue;
11980
11981 /* Find the first reloc has the same offset with label_rel. */
11982 while (insn_rel < irelend && insn_rel->r_offset < label_rel->r_offset)
11983 insn_rel++;
11984
11985 for (;insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset;
11986 insn_rel++)
11987 /* Check if there were R_NDS32_INSN16 and R_NDS32_LABEL at the same
11988 address. */
11989 if (ELF32_R_TYPE (insn_rel->r_info) == R_NDS32_INSN16)
11990 break;
11991
11992 if (insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset
11993 && insn_rel < label_rel)
11994 {
11995 /* Swap the two reloc if the R_NDS32_INSN16 is
11996 before R_NDS32_LABEL. */
11997 memcpy (&rel_temp, insn_rel, sizeof (Elf_Internal_Rela));
11998 memcpy (insn_rel, label_rel, sizeof (Elf_Internal_Rela));
11999 memcpy (label_rel, &rel_temp, sizeof (Elf_Internal_Rela));
12000 }
12001 }
12002
12003 label_rel = NULL;
12004 insn_rel = NULL;
12005 /* If there were a sequence of R_NDS32_LABEL end up with .align 2
12006 or higher, remove other R_NDS32_LABEL with lower alignment.
12007 If an R_NDS32_INSN16 in between R_NDS32_LABELs must be converted,
12008 then the R_NDS32_LABEL sequence is broke. */
12009 for (tmp_rel = internal_relocs; tmp_rel < irelend; tmp_rel++)
12010 {
12011 if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_LABEL)
12012 {
12013 if (label_rel == NULL)
12014 {
12015 if (tmp_rel->r_addend < 2)
12016 label_rel = tmp_rel;
12017 continue;
12018 }
12019 else if (tmp_rel->r_addend > 1)
12020 {
12021 /* Remove all LABEL relocation from label_rel to tmp_rel
12022 including relocations with same offset as tmp_rel. */
12023 for (tmp2_rel = label_rel; tmp2_rel < tmp_rel; tmp2_rel++)
12024 {
12025 if (tmp2_rel->r_offset == tmp_rel->r_offset)
12026 break;
12027
12028 if (ELF32_R_TYPE (tmp2_rel->r_info) == R_NDS32_LABEL
12029 && tmp2_rel->r_addend < 2)
12030 tmp2_rel->r_info =
12031 ELF32_R_INFO (ELF32_R_SYM (tmp2_rel->r_info),
12032 R_NDS32_NONE);
12033 }
12034 label_rel = NULL;
12035 }
12036 }
12037 else if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16 && label_rel)
12038 {
12039 /* A new INSN16 which can be converted, so clear label_rel. */
12040 if (is_convert_32_to_16 (abfd, sec, tmp_rel, internal_relocs,
12041 irelend, &insn16)
12042 || is_16bit_NOP (abfd, sec, tmp_rel))
12043 label_rel = NULL;
12044 }
12045 }
12046
12047 label_rel = NULL;
12048 insn_rel = NULL;
12049 /* Optimized for speed and nothing has not been relaxed.
12050 It's time to align labels.
12051 We may convert a 16-bit instruction right before a label to
12052 32-bit, in order to align the label if necessary
12053 all reloc entries has been sorted by r_offset. */
12054 for (irel = internal_relocs;
12055 irel < irelend && irel->r_offset < sec->size; irel++)
12056 {
12057 if (ELF32_R_TYPE (irel->r_info) != R_NDS32_INSN16
12058 && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL)
12059 continue;
12060
12061 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_INSN16)
12062 {
12063 /* A new INSN16 found, resize the old one. */
12064 if (is_convert_32_to_16
12065 (abfd, sec, irel, internal_relocs, irelend, &insn16)
12066 || is_16bit_NOP (abfd, sec, irel))
12067 {
12068 if (insn_rel)
12069 {
12070 /* Previous INSN16 reloc exists, reduce its
12071 size to 16-bit. */
12072 if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
12073 irelend, &insn16))
12074 {
12075 nds32_elf_write_16 (abfd, contents, insn_rel,
12076 internal_relocs, irelend, insn16);
12077
12078 if (!insert_nds32_elf_blank_recalc_total
12079 (relax_blank_list, insn_rel->r_offset + 2, 2))
12080 return FALSE;
12081 }
12082 else if (is_16bit_NOP (abfd, sec, insn_rel))
12083 {
12084 if (!insert_nds32_elf_blank_recalc_total
12085 (relax_blank_list, insn_rel->r_offset, 2))
12086 return FALSE;
12087 }
12088 insn_rel->r_info =
12089 ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info), R_NDS32_NONE);
12090 }
12091 /* Save the new one for later use. */
12092 insn_rel = irel;
12093 }
12094 else
12095 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
12096 R_NDS32_NONE);
12097 }
12098 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL)
12099 {
12100 /* Search for label. */
12101 int force_relax = 0;
12102
12103 /* Label on 16-bit instruction or optimization
12104 needless, just reset this reloc. */
12105 insn16 = bfd_getb16 (contents + irel->r_offset);
12106 if ((irel->r_addend & 0x1f) < 2 && (!optimize || (insn16 & 0x8000)))
12107 {
12108 irel->r_info =
12109 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
12110 continue;
12111 }
12112
12113 address =
12114 irel->r_offset - get_nds32_elf_blank_total (relax_blank_list,
12115 irel->r_offset, 1);
12116
12117 if (!insn_rel)
12118 {
12119 /* Check if there is case which can not be aligned. */
12120 if (irel->r_addend == 2 && address & 0x2)
12121 return FALSE;
12122 continue;
12123 }
12124
12125 /* Try to align this label. */
12126
12127 if ((irel->r_addend & 0x1f) < 2)
12128 {
12129 /* Check if there is a INSN16 at the same address.
12130 Label_rel always seats before insn_rel after
12131 our sort. */
12132
12133 /* Search for INSN16 at LABEL location. If INSN16 is at
12134 same location and this LABEL alignment is lower than 2,
12135 the INSN16 can be converted to 2-byte. */
12136 for (tmp_rel = irel;
12137 tmp_rel < irelend && tmp_rel->r_offset == irel->r_offset;
12138 tmp_rel++)
12139 {
12140 if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16
12141 && (is_convert_32_to_16
12142 (abfd, sec, tmp_rel, internal_relocs,
12143 irelend, &insn16)
12144 || is_16bit_NOP (abfd, sec, tmp_rel)))
12145 {
12146 force_relax = 1;
12147 break;
12148 }
12149 }
12150 }
12151
12152 if (force_relax || irel->r_addend == 1 || address & 0x2)
12153 {
12154 /* Label not aligned. */
12155 /* Previous reloc exists, reduce its size to 16-bit. */
12156 if (is_convert_32_to_16 (abfd, sec, insn_rel,
12157 internal_relocs, irelend, &insn16))
12158 {
12159 nds32_elf_write_16 (abfd, contents, insn_rel,
12160 internal_relocs, irelend, insn16);
12161
12162 if (!insert_nds32_elf_blank_recalc_total
12163 (relax_blank_list, insn_rel->r_offset + 2, 2))
12164 return FALSE;
12165 }
12166 else if (is_16bit_NOP (abfd, sec, insn_rel))
12167 {
12168 if (!insert_nds32_elf_blank_recalc_total
12169 (relax_blank_list, insn_rel->r_offset, 2))
12170 return FALSE;
12171 }
12172
12173 }
12174 /* INSN16 reloc is used. */
12175 insn_rel = NULL;
12176 }
12177 }
12178
12179 address =
12180 sec->size - get_nds32_elf_blank_total (relax_blank_list, sec->size, 0);
12181 if (insn_rel && (address & 0x2 || opt_size))
12182 {
12183 if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
12184 irelend, &insn16))
12185 {
12186 nds32_elf_write_16 (abfd, contents, insn_rel, internal_relocs,
12187 irelend, insn16);
12188 if (!insert_nds32_elf_blank_recalc_total
12189 (relax_blank_list, insn_rel->r_offset + 2, 2))
12190 return FALSE;
12191 insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
12192 R_NDS32_NONE);
12193 }
12194 else if (is_16bit_NOP (abfd, sec, insn_rel))
12195 {
12196 if (!insert_nds32_elf_blank_recalc_total
12197 (relax_blank_list, insn_rel->r_offset, 2))
12198 return FALSE;
12199 insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
12200 R_NDS32_NONE);
12201 }
12202 }
12203 insn_rel = NULL;
12204 return TRUE;
12205 }
12206
12207 static bfd_boolean
12208 nds32_elf_relax_section (bfd *abfd, asection *sec,
12209 struct bfd_link_info *link_info, bfd_boolean *again)
12210 {
12211 nds32_elf_blank_t *relax_blank_list = NULL;
12212 Elf_Internal_Shdr *symtab_hdr;
12213 Elf_Internal_Rela *internal_relocs;
12214 Elf_Internal_Rela *irel;
12215 Elf_Internal_Rela *irelend;
12216 Elf_Internal_Sym *isymbuf = NULL;
12217 bfd_byte *contents = NULL;
12218 bfd_boolean result = TRUE;
12219 int optimize = 0;
12220 int opt_size = 0;
12221 uint32_t insn;
12222 uint16_t insn16;
12223
12224 /* Target dependnet option. */
12225 struct elf_nds32_link_hash_table *table;
12226 int load_store_relax;
12227
12228 relax_blank_list = NULL;
12229
12230 *again = FALSE;
12231
12232 /* Nothing to do for
12233 * relocatable link or
12234 * non-relocatable section or
12235 * non-code section or
12236 * empty content or
12237 * no reloc entry. */
12238 if (bfd_link_relocatable (link_info)
12239 || (sec->flags & SEC_RELOC) == 0
12240 || (sec->flags & SEC_EXCLUDE) != 0
12241 || (sec->flags & SEC_CODE) == 0
12242 || sec->size == 0
12243 || sec->reloc_count == 0)
12244 return TRUE;
12245
12246 /* 09.12.11 Workaround. */
12247 /* We have to adjust align for R_NDS32_LABEL if needed.
12248 The adjust approach only can fix 2-byte align once. */
12249 if (sec->alignment_power > 2)
12250 return TRUE;
12251
12252 /* Do TLS model conversion once at first. */
12253 nds32_elf_unify_tls_model (abfd, sec, contents, link_info);
12254
12255 /* The optimization type to do. */
12256
12257 table = nds32_elf_hash_table (link_info);
12258
12259 /* Save the first section for abs symbol relaxation.
12260 This is used for checking gp relaxation in the
12261 nds32_elf_relax_loadstore and nds32_elf_relax_lo12. */
12262 nds32_elf_relax_guard (NULL, 0, sec, NULL, again, TRUE,
12263 table, NULL, NULL);
12264
12265 /* The begining of general relaxation. */
12266
12267 if (is_SDA_BASE_set == 0)
12268 {
12269 bfd_vma gp;
12270 is_SDA_BASE_set = 1;
12271 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
12272 &gp, FALSE);
12273 relax_range_measurement (abfd);
12274 }
12275
12276 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12277 /* Relocations MUST be kept in memory, because relaxation adjust them. */
12278 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
12279 TRUE /* keep_memory */);
12280 if (internal_relocs == NULL)
12281 goto error_return;
12282
12283 irelend = internal_relocs + sec->reloc_count;
12284 irel = find_relocs_at_address (internal_relocs, internal_relocs,
12285 irelend, R_NDS32_RELAX_ENTRY);
12286
12287 if (irel == irelend)
12288 return TRUE;
12289
12290 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
12291 {
12292 if (irel->r_addend & R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG)
12293 return TRUE;
12294
12295 if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FLAG)
12296 optimize = 1;
12297
12298 if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FOR_SPACE_FLAG)
12299 opt_size = 1;
12300 }
12301
12302 load_store_relax = table->load_store_relax;
12303
12304 /* Get symbol table and section content. */
12305 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12306 || !nds32_get_local_syms (abfd, sec, &isymbuf))
12307 goto error_return;
12308
12309 /* Do relax loop only when finalize is not done.
12310 Take care of relaxable relocs except INSN16. */
12311 for (irel = internal_relocs; irel < irelend; irel++)
12312 {
12313 int seq_len; /* Original length of instruction sequence. */
12314 int insn_len = 0; /* Final length of instruction sequence. */
12315 bfd_boolean removed;
12316
12317 insn = 0;
12318 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
12319 && (irel->r_addend & 0x1f) >= 2)
12320 optimize = 1;
12321
12322 /* Relocation Types
12323 R_NDS32_LONGCALL1 53
12324 R_NDS32_LONGCALL2 54
12325 R_NDS32_LONGCALL3 55
12326 R_NDS32_LONGJUMP1 56
12327 R_NDS32_LONGJUMP2 57
12328 R_NDS32_LONGJUMP3 58
12329 R_NDS32_LOADSTORE 59 */
12330 if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL1
12331 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LOADSTORE)
12332 seq_len = GET_SEQ_LEN (irel->r_addend);
12333
12334 /* Relocation Types
12335 R_NDS32_LONGCALL4 107
12336 R_NDS32_LONGCALL5 108
12337 R_NDS32_LONGCALL6 109
12338 R_NDS32_LONGJUMP4 110
12339 R_NDS32_LONGJUMP5 111
12340 R_NDS32_LONGJUMP6 112
12341 R_NDS32_LONGJUMP7 113 */
12342 else if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL4
12343 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LONGJUMP7)
12344 seq_len = 4;
12345
12346 /* Relocation Types
12347 R_NDS32_LO12S0_RELA 30
12348 R_NDS32_LO12S1_RELA 29
12349 R_NDS32_LO12S2_RELA 28
12350 R_NDS32_LO12S2_SP_RELA 71
12351 R_NDS32_LO12S2_DP_RELA 70
12352 R_NDS32_GOT_LO12 46
12353 R_NDS32_GOTOFF_LO12 50
12354 R_NDS32_PLTREL_LO12 65
12355 R_NDS32_PLT_GOTREL_LO12 67
12356 R_NDS32_17IFC_PCREL_RELA 96
12357 R_NDS32_GOT_SUFF 193
12358 R_NDS32_GOTOFF_SUFF 194
12359 R_NDS32_PLT_GOT_SUFF 195
12360 R_NDS32_MULCALL_SUFF 196
12361 R_NDS32_PTR 197 */
12362 else if ((ELF32_R_TYPE (irel->r_info) <= R_NDS32_LO12S0_RELA
12363 && ELF32_R_TYPE (irel->r_info) >= R_NDS32_LO12S2_RELA)
12364 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_SP_RELA
12365 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_DP_RELA
12366 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12
12367 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12
12368 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12
12369 || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLTREL_LO12
12370 || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12
12371 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_GOT_SUFF
12372 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_PTR)
12373 || ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12374 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LO12
12375 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_ADD
12376 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LS
12377 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LSI)
12378 seq_len = 0;
12379 else
12380 continue;
12381
12382 insn_len = seq_len;
12383 removed = FALSE;
12384
12385 switch (ELF32_R_TYPE (irel->r_info))
12386 {
12387 case R_NDS32_LONGCALL1:
12388 removed = nds32_elf_relax_longcall1 (abfd, sec, irel, internal_relocs,
12389 &insn_len, contents, isymbuf,
12390 symtab_hdr);
12391 break;
12392 case R_NDS32_LONGCALL2:
12393 removed = nds32_elf_relax_longcall2 (abfd, sec, irel, internal_relocs,
12394 &insn_len, contents, isymbuf,
12395 symtab_hdr);
12396 break;
12397 case R_NDS32_LONGCALL3:
12398 removed = nds32_elf_relax_longcall3 (abfd, sec, irel, internal_relocs,
12399 &insn_len, contents, isymbuf,
12400 symtab_hdr);
12401 break;
12402 case R_NDS32_LONGJUMP1:
12403 removed = nds32_elf_relax_longjump1 (abfd, sec, irel, internal_relocs,
12404 &insn_len, contents, isymbuf,
12405 symtab_hdr);
12406 break;
12407 case R_NDS32_LONGJUMP2:
12408 removed = nds32_elf_relax_longjump2 (abfd, sec, irel, internal_relocs,
12409 &insn_len, contents, isymbuf,
12410 symtab_hdr);
12411 break;
12412 case R_NDS32_LONGJUMP3:
12413 removed = nds32_elf_relax_longjump3 (abfd, sec, irel, internal_relocs,
12414 &insn_len, contents, isymbuf,
12415 symtab_hdr);
12416 break;
12417 case R_NDS32_LONGCALL4:
12418 removed = nds32_elf_relax_longcall4 (abfd, sec, irel, internal_relocs,
12419 &insn_len, contents, isymbuf,
12420 symtab_hdr);
12421 break;
12422 case R_NDS32_LONGCALL5:
12423 removed = nds32_elf_relax_longcall5 (abfd, sec, irel, internal_relocs,
12424 &insn_len, contents, isymbuf,
12425 symtab_hdr);
12426 break;
12427 case R_NDS32_LONGCALL6:
12428 removed = nds32_elf_relax_longcall6 (abfd, sec, irel, internal_relocs,
12429 &insn_len, contents, isymbuf,
12430 symtab_hdr);
12431 break;
12432 case R_NDS32_LONGJUMP4:
12433 removed = nds32_elf_relax_longjump4 (abfd, sec, irel, internal_relocs,
12434 &insn_len, contents, isymbuf,
12435 symtab_hdr);
12436 break;
12437 case R_NDS32_LONGJUMP5:
12438 removed = nds32_elf_relax_longjump5 (abfd, sec, irel, internal_relocs,
12439 &insn_len, &seq_len, contents,
12440 isymbuf, symtab_hdr);
12441 break;
12442 case R_NDS32_LONGJUMP6:
12443 removed = nds32_elf_relax_longjump6 (abfd, sec, irel, internal_relocs,
12444 &insn_len, &seq_len, contents,
12445 isymbuf, symtab_hdr);
12446 break;
12447 case R_NDS32_LONGJUMP7:
12448 removed = nds32_elf_relax_longjump7 (abfd, sec, irel, internal_relocs,
12449 &insn_len, &seq_len, contents,
12450 isymbuf, symtab_hdr);
12451 break;
12452 case R_NDS32_LOADSTORE:
12453 removed = nds32_elf_relax_loadstore (link_info, abfd, sec, irel,
12454 internal_relocs, &insn_len,
12455 contents, isymbuf, symtab_hdr,
12456 load_store_relax, table);
12457 break;
12458 case R_NDS32_LO12S0_RELA:
12459 case R_NDS32_LO12S1_RELA:
12460 case R_NDS32_LO12S2_RELA:
12461 case R_NDS32_LO12S2_DP_RELA:
12462 case R_NDS32_LO12S2_SP_RELA:
12463 /* Relax for low part. */
12464 nds32_elf_relax_lo12 (link_info, abfd, sec, irel, internal_relocs,
12465 contents, isymbuf, symtab_hdr, table);
12466
12467 /* It is impossible to delete blank, so just continue. */
12468 continue;
12469 case R_NDS32_PTR:
12470 removed = nds32_elf_relax_ptr (abfd, sec, irel, internal_relocs,
12471 &insn_len, &seq_len, contents);
12472 break;
12473 case R_NDS32_LSI:
12474 nds32_elf_relax_flsi (link_info, abfd, sec, irel, internal_relocs,
12475 contents, isymbuf, symtab_hdr, again);
12476 continue;
12477 case R_NDS32_GOT_LO12:
12478 case R_NDS32_GOTOFF_LO12:
12479 case R_NDS32_PLTREL_LO12:
12480 case R_NDS32_PLT_GOTREL_LO12:
12481 case R_NDS32_GOTPC_LO12:
12482 case R_NDS32_TLS_LE_LO12:
12483 case R_NDS32_TLS_LE_ADD:
12484 case R_NDS32_TLS_LE_LS:
12485 case R_NDS32_PLT_GOT_SUFF:
12486 case R_NDS32_GOT_SUFF:
12487 case R_NDS32_GOTOFF_SUFF:
12488 continue;
12489 default:
12490 continue;
12491 }
12492
12493 if (removed && seq_len - insn_len > 0)
12494 {
12495 if (!insert_nds32_elf_blank
12496 (&relax_blank_list, irel->r_offset + insn_len,
12497 seq_len - insn_len))
12498 goto error_return;
12499 *again = TRUE;
12500 }
12501 }
12502
12503 calc_nds32_blank_total (relax_blank_list);
12504
12505 if (table->relax_fp_as_gp)
12506 {
12507 if (!nds32_relax_fp_as_gp (link_info, abfd, sec, internal_relocs,
12508 irelend, isymbuf))
12509 goto error_return;
12510
12511 if (!*again)
12512 {
12513 if (!nds32_fag_remove_unused_fpbase (abfd, sec, internal_relocs,
12514 irelend))
12515 goto error_return;
12516 }
12517 }
12518
12519 if (!*again)
12520 {
12521 if (!nds32_relax_adjust_label (abfd, sec, internal_relocs, contents,
12522 &relax_blank_list, optimize, opt_size))
12523 goto error_return;
12524 }
12525
12526 /* It doesn't matter optimize_for_space_no_align anymore.
12527 If object file is assembled with flag '-Os',
12528 the we don't adjust jump-destination on 4-byte boundary. */
12529
12530 if (relax_blank_list)
12531 {
12532 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12533 relax_blank_list = NULL;
12534 }
12535
12536 if (!*again)
12537 {
12538 /* Closing the section, so we don't relax it anymore. */
12539 bfd_vma sec_size_align;
12540 Elf_Internal_Rela *tmp_rel;
12541
12542 /* Pad to alignment boundary. Only handle current section alignment. */
12543 sec_size_align = (sec->size + (~((-1U) << sec->alignment_power)))
12544 & ((-1U) << sec->alignment_power);
12545 if ((sec_size_align - sec->size) & 0x2)
12546 {
12547 insn16 = NDS32_NOP16;
12548 bfd_putb16 (insn16, contents + sec->size);
12549 sec->size += 2;
12550 }
12551
12552 while (sec_size_align != sec->size)
12553 {
12554 insn = NDS32_NOP32;
12555 bfd_putb32 (insn, contents + sec->size);
12556 sec->size += 4;
12557 }
12558
12559 tmp_rel = find_relocs_at_address (internal_relocs, internal_relocs,
12560 irelend, R_NDS32_RELAX_ENTRY);
12561 if (tmp_rel != irelend)
12562 tmp_rel->r_addend |= R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG;
12563
12564 clean_nds32_elf_blank ();
12565 }
12566
12567 finish:
12568 if (internal_relocs != NULL
12569 && elf_section_data (sec)->relocs != internal_relocs)
12570 free (internal_relocs);
12571
12572 if (contents != NULL
12573 && elf_section_data (sec)->this_hdr.contents != contents)
12574 free (contents);
12575
12576 if (isymbuf != NULL && symtab_hdr->contents != (bfd_byte *) isymbuf)
12577 free (isymbuf);
12578
12579 return result;
12580
12581 error_return:
12582 result = FALSE;
12583 goto finish;
12584 }
12585
12586 static struct bfd_elf_special_section const nds32_elf_special_sections[] =
12587 {
12588 {".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE},
12589 {".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE},
12590 {NULL, 0, 0, 0, 0}
12591 };
12592
12593 static bfd_boolean
12594 nds32_elf_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
12595 struct bfd_link_info *info,
12596 void *finfo ATTRIBUTE_UNUSED,
12597 bfd_boolean (*func) (void *, const char *,
12598 Elf_Internal_Sym *,
12599 asection *,
12600 struct elf_link_hash_entry *)
12601 ATTRIBUTE_UNUSED)
12602 {
12603 FILE *sym_ld_script = NULL;
12604 struct elf_nds32_link_hash_table *table;
12605
12606 table = nds32_elf_hash_table (info);
12607 sym_ld_script = table->sym_ld_script;
12608
12609 if (check_start_export_sym)
12610 fprintf (sym_ld_script, "}\n");
12611
12612 return TRUE;
12613 }
12614
12615 static enum elf_reloc_type_class
12616 nds32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
12617 const asection *rel_sec ATTRIBUTE_UNUSED,
12618 const Elf_Internal_Rela *rela)
12619 {
12620 switch ((int) ELF32_R_TYPE (rela->r_info))
12621 {
12622 case R_NDS32_RELATIVE:
12623 return reloc_class_relative;
12624 case R_NDS32_JMP_SLOT:
12625 return reloc_class_plt;
12626 case R_NDS32_COPY:
12627 return reloc_class_copy;
12628 default:
12629 return reloc_class_normal;
12630 }
12631 }
12632
12633 /* Put target dependent option into info hash table. */
12634 void
12635 bfd_elf32_nds32_set_target_option (struct bfd_link_info *link_info,
12636 int relax_fp_as_gp,
12637 int eliminate_gc_relocs,
12638 FILE * sym_ld_script,
12639 int hyper_relax,
12640 int tls_desc_trampoline,
12641 int load_store_relax)
12642 {
12643 struct elf_nds32_link_hash_table *table;
12644
12645 table = nds32_elf_hash_table (link_info);
12646 if (table == NULL)
12647 return;
12648
12649 table->relax_fp_as_gp = relax_fp_as_gp;
12650 table->eliminate_gc_relocs = eliminate_gc_relocs;
12651 table->sym_ld_script = sym_ld_script;
12652 table->hyper_relax = hyper_relax;
12653 table->tls_desc_trampoline = tls_desc_trampoline;
12654 table ->load_store_relax = load_store_relax;
12655 }
12656 \f
12657
12658 /* These functions and data-structures are used for fp-as-gp
12659 optimization. */
12660
12661 #define FAG_THRESHOLD 3 /* At least 3 gp-access. */
12662 /* lwi37.fp covers 508 bytes, but there may be 32-byte padding between
12663 the read-only section and read-write section. */
12664 #define FAG_WINDOW (508 - 32)
12665
12666 /* An nds32_fag represent a gp-relative access.
12667 We find best fp-base by using a sliding window
12668 to find a base address which can cover most gp-access. */
12669 struct nds32_fag
12670 {
12671 struct nds32_fag *next; /* NULL-teminated linked list. */
12672 bfd_vma addr; /* The address of this fag. */
12673 Elf_Internal_Rela **relas; /* The relocations associated with this fag.
12674 It is used for applying FP7U2_FLAG. */
12675 int count; /* How many times this address is referred.
12676 There should be exactly `count' relocations
12677 in relas. */
12678 int relas_capcity; /* The buffer size of relas.
12679 We use an array instead of linked-list,
12680 and realloc is used to adjust buffer size. */
12681 };
12682
12683 static void
12684 nds32_fag_init (struct nds32_fag *head)
12685 {
12686 memset (head, 0, sizeof (struct nds32_fag));
12687 }
12688
12689 static void
12690 nds32_fag_verify (struct nds32_fag *head)
12691 {
12692 struct nds32_fag *iter;
12693 struct nds32_fag *prev;
12694
12695 prev = NULL;
12696 iter = head->next;
12697 while (iter)
12698 {
12699 if (prev && prev->addr >= iter->addr)
12700 puts ("Bug in fp-as-gp insertion.");
12701 prev = iter;
12702 iter = iter->next;
12703 }
12704 }
12705
12706 /* Insert a fag in ascending order.
12707 If a fag of the same address already exists,
12708 they are chained by relas array. */
12709
12710 static void
12711 nds32_fag_insert (struct nds32_fag *head, bfd_vma addr,
12712 Elf_Internal_Rela * rel)
12713 {
12714 struct nds32_fag *iter;
12715 struct nds32_fag *new_fag;
12716 const int INIT_RELAS_CAP = 4;
12717
12718 for (iter = head;
12719 iter->next && iter->next->addr <= addr;
12720 iter = iter->next)
12721 /* Find somewhere to insert. */ ;
12722
12723 /* `iter' will be equal to `head' if the list is empty. */
12724 if (iter != head && iter->addr == addr)
12725 {
12726 /* The address exists in the list.
12727 Insert `rel' into relocation list, relas. */
12728
12729 /* Check whether relas is big enough. */
12730 if (iter->count >= iter->relas_capcity)
12731 {
12732 iter->relas_capcity *= 2;
12733 iter->relas = bfd_realloc
12734 (iter->relas, iter->relas_capcity * sizeof (void *));
12735 }
12736 iter->relas[iter->count++] = rel;
12737 return;
12738 }
12739
12740 /* This is a new address. Create a fag node for it. */
12741 new_fag = bfd_malloc (sizeof (struct nds32_fag));
12742 memset (new_fag, 0, sizeof (*new_fag));
12743 new_fag->addr = addr;
12744 new_fag->count = 1;
12745 new_fag->next = iter->next;
12746 new_fag->relas_capcity = INIT_RELAS_CAP;
12747 new_fag->relas = (Elf_Internal_Rela **)
12748 bfd_malloc (new_fag->relas_capcity * sizeof (void *));
12749 new_fag->relas[0] = rel;
12750 iter->next = new_fag;
12751
12752 nds32_fag_verify (head);
12753 }
12754
12755 static void
12756 nds32_fag_free_list (struct nds32_fag *head)
12757 {
12758 struct nds32_fag *iter;
12759
12760 iter = head->next;
12761 while (iter)
12762 {
12763 struct nds32_fag *tmp = iter;
12764 iter = iter->next;
12765 free (tmp->relas);
12766 tmp->relas = NULL;
12767 free (tmp);
12768 }
12769 }
12770
12771 /* Find the best fp-base address.
12772 The relocation associated with that address is returned,
12773 so we can track the symbol instead of a fixed address.
12774
12775 When relaxation, the address of an datum may change,
12776 because a text section is shrinked, so the data section
12777 moves forward. If the aligments of text and data section
12778 are different, their distance may change too.
12779 Therefore, tracking a fixed address is not appriate. */
12780
12781 static int
12782 nds32_fag_find_base (struct nds32_fag *head, struct nds32_fag **bestpp)
12783 {
12784 struct nds32_fag *base; /* First fag in the window. */
12785 struct nds32_fag *last; /* First fag outside the window. */
12786 int accu = 0; /* Usage accumulation. */
12787 struct nds32_fag *best; /* Best fag. */
12788 int baccu = 0; /* Best accumulation. */
12789
12790 /* Use first fag for initial, and find the last fag in the window.
12791
12792 In each iteration, we could simply subtract previous fag
12793 and accumulate following fags which are inside the window,
12794 untill we each the end. */
12795
12796 if (head->next == NULL)
12797 {
12798 *bestpp = NULL;
12799 return 0;
12800 }
12801
12802 /* Initialize base. */
12803 base = head->next;
12804 best = base;
12805 for (last = base;
12806 last && last->addr < base->addr + FAG_WINDOW;
12807 last = last->next)
12808 accu += last->count;
12809
12810 baccu = accu;
12811
12812 /* Record the best base in each iteration. */
12813 while (base->next)
12814 {
12815 accu -= base->count;
12816 base = base->next;
12817 /* Account fags in window. */
12818 for (/* Nothing. */;
12819 last && last->addr < base->addr + FAG_WINDOW;
12820 last = last->next)
12821 accu += last->count;
12822
12823 /* A better fp-base? */
12824 if (accu > baccu)
12825 {
12826 best = base;
12827 baccu = accu;
12828 }
12829 }
12830
12831 if (bestpp)
12832 *bestpp = best;
12833 return baccu;
12834 }
12835
12836 /* Apply R_NDS32_INSN16_FP7U2_FLAG on gp-relative accesses,
12837 so we can convert it fo fp-relative access later.
12838 `best_fag' is the best fp-base. Only those inside the window
12839 of best_fag is applied the flag. */
12840
12841 static bfd_boolean
12842 nds32_fag_mark_relax (struct bfd_link_info *link_info,
12843 asection *sec, struct nds32_fag *best_fag,
12844 Elf_Internal_Rela *internal_relocs,
12845 Elf_Internal_Rela *irelend)
12846 {
12847 struct nds32_fag *ifag;
12848 bfd_vma best_fpbase, gp;
12849 bfd *output_bfd;
12850
12851 output_bfd = sec->output_section->owner;
12852 nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
12853 best_fpbase = best_fag->addr;
12854
12855 if (best_fpbase > gp + sdata_range[1][1]
12856 || best_fpbase < gp - sdata_range[1][0])
12857 return FALSE;
12858
12859 /* Mark these inside the window R_NDS32_INSN16_FP7U2_FLAG flag,
12860 so we know they can be converted to lwi37.fp. */
12861 for (ifag = best_fag;
12862 ifag && ifag->addr < best_fpbase + FAG_WINDOW; ifag = ifag->next)
12863 {
12864 int i;
12865
12866 for (i = 0; i < ifag->count; i++)
12867 {
12868 Elf_Internal_Rela *insn16_rel;
12869 Elf_Internal_Rela *fag_rel;
12870
12871 fag_rel = ifag->relas[i];
12872
12873 /* Only if this is within the WINDOWS, FP7U2_FLAG
12874 is applied. */
12875
12876 insn16_rel = find_relocs_at_address
12877 (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12878
12879 if (insn16_rel != irelend)
12880 insn16_rel->r_addend = R_NDS32_INSN16_FP7U2_FLAG;
12881 }
12882 }
12883 return TRUE;
12884 }
12885
12886 /* Reset INSN16 to clean fp as gp. */
12887
12888 static void
12889 nds32_fag_unmark_relax (struct nds32_fag *fag,
12890 Elf_Internal_Rela *internal_relocs,
12891 Elf_Internal_Rela *irelend)
12892 {
12893 struct nds32_fag *ifag;
12894 int i;
12895 Elf_Internal_Rela *insn16_rel;
12896 Elf_Internal_Rela *fag_rel;
12897
12898 for (ifag = fag; ifag; ifag = ifag->next)
12899 {
12900 for (i = 0; i < ifag->count; i++)
12901 {
12902 fag_rel = ifag->relas[i];
12903
12904 /* Restore the INSN16 relocation. */
12905 insn16_rel = find_relocs_at_address
12906 (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12907
12908 if (insn16_rel != irelend)
12909 insn16_rel->r_addend &= ~R_NDS32_INSN16_FP7U2_FLAG;
12910 }
12911 }
12912 }
12913
12914 /* This is the main function of fp-as-gp optimization.
12915 It should be called by relax_section. */
12916
12917 static bfd_boolean
12918 nds32_relax_fp_as_gp (struct bfd_link_info *link_info,
12919 bfd *abfd, asection *sec,
12920 Elf_Internal_Rela *internal_relocs,
12921 Elf_Internal_Rela *irelend,
12922 Elf_Internal_Sym *isymbuf)
12923 {
12924 Elf_Internal_Rela *begin_rel = NULL;
12925 Elf_Internal_Rela *irel;
12926 struct nds32_fag fag_head;
12927 Elf_Internal_Shdr *symtab_hdr;
12928 bfd_byte *contents;
12929 bfd_boolean ifc_inside = FALSE;
12930
12931 /* FIXME: Can we bfd_elf_link_read_relocs for the relocs? */
12932
12933 /* Per-function fp-base selection.
12934 1. Create a list for all the gp-relative access.
12935 2. Base on those gp-relative address,
12936 find a fp-base which can cover most access.
12937 3. Use the fp-base for fp-as-gp relaxation.
12938
12939 NOTE: If fp-as-gp is not worth to do, (e.g., less than 3 times),
12940 we should
12941 1. delete the `la $fp, _FP_BASE_' instruction and
12942 2. not convert lwi.gp to lwi37.fp.
12943
12944 To delete the _FP_BASE_ instruction, we simply apply
12945 R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG flag in the r_addend to disable it.
12946
12947 To suppress the conversion, we simply NOT to apply
12948 R_NDS32_INSN16_FP7U2_FLAG flag. */
12949
12950 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12951
12952 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12953 || !nds32_get_local_syms (abfd, sec, &isymbuf))
12954 return FALSE;
12955
12956 /* Check whether it is worth for fp-as-gp optimization,
12957 i.e., at least 3 gp-load.
12958
12959 Set R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG if we should NOT
12960 apply this optimization. */
12961
12962 for (irel = internal_relocs; irel < irelend; irel++)
12963 {
12964 /* We recognize R_NDS32_RELAX_REGION_BEGIN/_END for the region.
12965 One we enter the begin of the region, we track all the LW/ST
12966 instructions, so when we leave the region, we try to find
12967 the best fp-base address for those LW/ST instructions. */
12968
12969 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12970 && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12971 {
12972 /* Begin of the region. */
12973 if (begin_rel)
12974 /* xgettext:c-format */
12975 _bfd_error_handler (_("%pB: nested OMIT_FP in %pA"), abfd, sec);
12976
12977 begin_rel = irel;
12978 nds32_fag_init (&fag_head);
12979 ifc_inside = FALSE;
12980 }
12981 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
12982 && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12983 {
12984 int accu;
12985 struct nds32_fag *best_fag, *tmp_fag;
12986 int dist;
12987
12988 /* End of the region.
12989 Check whether it is worth to do fp-as-gp. */
12990
12991 if (begin_rel == NULL)
12992 {
12993 /* xgettext:c-format */
12994 _bfd_error_handler (_("%pB: unmatched OMIT_FP in %pA"),
12995 abfd, sec);
12996 continue;
12997 }
12998
12999 accu = nds32_fag_find_base (&fag_head, &best_fag);
13000
13001 /* Clean FP7U2_FLAG because they may set ever. */
13002 tmp_fag = fag_head.next;
13003 nds32_fag_unmark_relax (tmp_fag, internal_relocs, irelend);
13004
13005 /* Check if it is worth, and FP_BASE is near enough to SDA_BASE. */
13006 if (accu < FAG_THRESHOLD
13007 || !nds32_fag_mark_relax (link_info, sec, best_fag,
13008 internal_relocs, irelend))
13009 {
13010 /* Not worth to do fp-as-gp. */
13011 begin_rel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
13012 begin_rel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
13013 irel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
13014 irel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
13015 nds32_fag_free_list (&fag_head);
13016 begin_rel = NULL;
13017 continue;
13018 }
13019
13020 /* R_SYM of R_NDS32_RELAX_REGION_BEGIN is not used by assembler,
13021 so we use it to record the distance to the reloction of best
13022 fp-base. */
13023 dist = best_fag->relas[0] - begin_rel;
13024 BFD_ASSERT (dist > 0 && dist < 0xffffff);
13025 /* Use high 16 bits of addend to record the _FP_BASE_ matched
13026 relocation. And get the base value when relocating. */
13027 begin_rel->r_addend &= (0x1 << 16) - 1;
13028 begin_rel->r_addend |= dist << 16;
13029
13030 nds32_fag_free_list (&fag_head);
13031 begin_rel = NULL;
13032 }
13033
13034 if (begin_rel == NULL || ifc_inside)
13035 /* Skip if we are not in the region of fp-as-gp. */
13036 continue;
13037
13038 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S2_RELA
13039 || ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA17S2_RELA)
13040 {
13041 bfd_vma addr;
13042 uint32_t insn;
13043
13044 /* A gp-relative access is found. Insert it to the fag-list. */
13045
13046 /* Rt is necessary an RT3, so it can be converted to lwi37.fp. */
13047 insn = bfd_getb32 (contents + irel->r_offset);
13048 if (!N32_IS_RT3 (insn))
13049 continue;
13050
13051 addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
13052 nds32_fag_insert (&fag_head, addr, irel);
13053 }
13054 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA_FP7U2_RELA)
13055 {
13056 begin_rel = NULL;
13057 }
13058 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
13059 || ELF32_R_TYPE (irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
13060 {
13061 /* Suppress fp as gp when encounter ifc. */
13062 ifc_inside = TRUE;
13063 }
13064 }
13065
13066 return TRUE;
13067 }
13068
13069 /* Remove unused `la $fp, _FD_BASE_' instruction. */
13070
13071 static bfd_boolean
13072 nds32_fag_remove_unused_fpbase (bfd *abfd, asection *sec,
13073 Elf_Internal_Rela *internal_relocs,
13074 Elf_Internal_Rela *irelend)
13075 {
13076 Elf_Internal_Rela *irel;
13077 Elf_Internal_Shdr *symtab_hdr;
13078 bfd_byte *contents = NULL;
13079 nds32_elf_blank_t *relax_blank_list = NULL;
13080 bfd_boolean result = TRUE;
13081 bfd_boolean unused_region = FALSE;
13082
13083 /*
13084 NOTE: Disable fp-as-gp if we encounter ifcall relocations:
13085 R_NDS32_17IFC_PCREL_RELA
13086 R_NDS32_10IFCU_PCREL_RELA. */
13087
13088 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13089 nds32_get_section_contents (abfd, sec, &contents, TRUE);
13090
13091 for (irel = internal_relocs; irel < irelend; irel++)
13092 {
13093 /* To remove unused fp-base, we simply find the REGION_NOT_OMIT_FP
13094 we marked to in previous pass.
13095 DO NOT scan relocations again, since we've alreadly decided it
13096 and set the flag. */
13097 const char *syname;
13098 int syndx;
13099 uint32_t insn;
13100
13101 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
13102 && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
13103 unused_region = TRUE;
13104 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
13105 && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
13106 unused_region = FALSE;
13107
13108 /* We're not in the region. */
13109 if (!unused_region)
13110 continue;
13111
13112 /* _FP_BASE_ must be a GLOBAL symbol. */
13113 syndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
13114 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
13115 continue;
13116
13117 /* The symbol name must be _FP_BASE_. */
13118 syname = elf_sym_hashes (abfd)[syndx]->root.root.string;
13119 if (strcmp (syname, FP_BASE_NAME) != 0)
13120 continue;
13121
13122 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA19S0_RELA)
13123 {
13124 /* addi.gp $fp, -256 */
13125 insn = bfd_getb32 (contents + irel->r_offset);
13126 if (insn != INSN_ADDIGP_TO_FP)
13127 continue;
13128 }
13129 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S0_RELA)
13130 {
13131 /* addi $fp, $gp, -256 */
13132 insn = bfd_getb32 (contents + irel->r_offset);
13133 if (insn != INSN_ADDI_GP_TO_FP)
13134 continue;
13135 }
13136 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_20_RELA)
13137 {
13138 /* movi $fp, FP_BASE */
13139 insn = bfd_getb32 (contents + irel->r_offset);
13140 if (insn != INSN_MOVI_TO_FP)
13141 continue;
13142 }
13143 else
13144 continue;
13145
13146 /* We got here because a FP_BASE instruction is found. */
13147 if (!insert_nds32_elf_blank_recalc_total
13148 (&relax_blank_list, irel->r_offset, 4))
13149 goto error_return;
13150 }
13151
13152 finish:
13153 if (relax_blank_list)
13154 {
13155 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
13156 relax_blank_list = NULL;
13157 }
13158 return result;
13159
13160 error_return:
13161 result = FALSE;
13162 goto finish;
13163 }
13164
13165 /* This is a version of bfd_generic_get_relocated_section_contents.
13166 We need this variety because relaxation will modify the dwarf
13167 infomation. When there is undefined symbol reference error mesage,
13168 linker need to dump line number where the symbol be used. However
13169 the address is be relaxed, it can not get the original dwarf contents.
13170 The variety only modify function call for reading in the section. */
13171
13172 static bfd_byte *
13173 nds32_elf_get_relocated_section_contents (bfd *abfd,
13174 struct bfd_link_info *link_info,
13175 struct bfd_link_order *link_order,
13176 bfd_byte *data,
13177 bfd_boolean relocatable,
13178 asymbol **symbols)
13179 {
13180 bfd *input_bfd = link_order->u.indirect.section->owner;
13181 asection *input_section = link_order->u.indirect.section;
13182 long reloc_size;
13183 arelent **reloc_vector;
13184 long reloc_count;
13185
13186 reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
13187 if (reloc_size < 0)
13188 return NULL;
13189
13190 /* Read in the section. */
13191 if (!nds32_get_section_contents (input_bfd, input_section, &data, FALSE))
13192 return NULL;
13193
13194 if (reloc_size == 0)
13195 return data;
13196
13197 reloc_vector = (arelent **) bfd_malloc (reloc_size);
13198 if (reloc_vector == NULL)
13199 return NULL;
13200
13201 reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
13202 reloc_vector, symbols);
13203 if (reloc_count < 0)
13204 goto error_return;
13205
13206 if (reloc_count > 0)
13207 {
13208 arelent **parent;
13209 for (parent = reloc_vector; *parent != NULL; parent++)
13210 {
13211 char *error_message = NULL;
13212 asymbol *symbol;
13213 bfd_reloc_status_type r;
13214
13215 symbol = *(*parent)->sym_ptr_ptr;
13216 if (symbol->section && discarded_section (symbol->section))
13217 {
13218 bfd_vma off;
13219 static reloc_howto_type none_howto
13220 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL,
13221 "unused", FALSE, 0, 0, FALSE);
13222
13223 off = (*parent)->address * bfd_octets_per_byte (input_bfd);
13224 _bfd_clear_contents ((*parent)->howto, input_bfd,
13225 input_section, data, off);
13226 (*parent)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
13227 (*parent)->addend = 0;
13228 (*parent)->howto = &none_howto;
13229 r = bfd_reloc_ok;
13230 }
13231 else
13232 r = bfd_perform_relocation (input_bfd, *parent, data,
13233 input_section,
13234 relocatable ? abfd : NULL,
13235 &error_message);
13236
13237 if (relocatable)
13238 {
13239 asection *os = input_section->output_section;
13240
13241 /* A partial link, so keep the relocs. */
13242 os->orelocation[os->reloc_count] = *parent;
13243 os->reloc_count++;
13244 }
13245
13246 if (r != bfd_reloc_ok)
13247 {
13248 switch (r)
13249 {
13250 case bfd_reloc_undefined:
13251 (*link_info->callbacks->undefined_symbol)
13252 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13253 input_bfd, input_section, (*parent)->address, TRUE);
13254 break;
13255 case bfd_reloc_dangerous:
13256 BFD_ASSERT (error_message != NULL);
13257 (*link_info->callbacks->reloc_dangerous)
13258 (link_info, error_message,
13259 input_bfd, input_section, (*parent)->address);
13260 break;
13261 case bfd_reloc_overflow:
13262 (*link_info->callbacks->reloc_overflow)
13263 (link_info, NULL,
13264 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13265 (*parent)->howto->name, (*parent)->addend,
13266 input_bfd, input_section, (*parent)->address);
13267 break;
13268 case bfd_reloc_outofrange:
13269 /* PR ld/13730:
13270 This error can result when processing some partially
13271 complete binaries. Do not abort, but issue an error
13272 message instead. */
13273 link_info->callbacks->einfo
13274 /* xgettext:c-format */
13275 (_("%X%P: %pB(%pA): relocation \"%pR\" goes out of range\n"),
13276 abfd, input_section, * parent);
13277 goto error_return;
13278
13279 default:
13280 abort ();
13281 break;
13282 }
13283 }
13284 }
13285 }
13286
13287 free (reloc_vector);
13288 return data;
13289
13290 error_return:
13291 free (reloc_vector);
13292 return NULL;
13293 }
13294
13295 /* Check target symbol. */
13296
13297 static bfd_boolean
13298 nds32_elf_is_target_special_symbol (bfd *abfd ATTRIBUTE_UNUSED, asymbol *sym)
13299 {
13300 if (!sym || !sym->name || sym->name[0] != '$')
13301 return FALSE;
13302 return TRUE;
13303 }
13304
13305 /* nds32 find maybe function sym. Ignore target special symbol
13306 first, and then go the general function. */
13307
13308 static bfd_size_type
13309 nds32_elf_maybe_function_sym (const asymbol *sym, asection *sec,
13310 bfd_vma *code_off)
13311 {
13312 if (nds32_elf_is_target_special_symbol (NULL, (asymbol *) sym))
13313 return 0;
13314
13315 return _bfd_elf_maybe_function_sym (sym, sec, code_off);
13316 }
13317 \f
13318
13319 /* Do TLS model conversion. */
13320
13321 typedef struct relax_group_list_t
13322 {
13323 Elf_Internal_Rela *relo;
13324 struct relax_group_list_t *next;
13325 struct relax_group_list_t *next_sibling;
13326 int id;
13327 } relax_group_list_t;
13328
13329 int
13330 list_insert (relax_group_list_t *pHead, Elf_Internal_Rela *pElem);
13331
13332 int
13333 list_insert_sibling (relax_group_list_t *pNode, Elf_Internal_Rela *pElem);
13334
13335 void
13336 dump_chain (relax_group_list_t *pHead);
13337
13338 int
13339 list_insert (relax_group_list_t *pHead, Elf_Internal_Rela *pElem)
13340 {
13341 relax_group_list_t *pNext = pHead;
13342
13343 /* Find place. */
13344 while (pNext->next)
13345 {
13346 if (pNext->next->id > (int) pElem->r_addend)
13347 break;
13348
13349 pNext = pNext->next;
13350 }
13351
13352 /* Insert node. */
13353 relax_group_list_t *pNew = bfd_malloc (sizeof (relax_group_list_t));
13354 if (!pNew)
13355 return FALSE;
13356
13357 relax_group_list_t *tmp = pNext->next;
13358 pNext->next = pNew;
13359
13360 pNew->id = pElem->r_addend;
13361 pNew->relo = pElem;
13362 pNew->next = tmp;
13363 pNew->next_sibling = NULL;
13364
13365 return TRUE;
13366 }
13367
13368 int
13369 list_insert_sibling (relax_group_list_t *pNode, Elf_Internal_Rela *pElem)
13370 {
13371 relax_group_list_t *pNext = pNode;
13372
13373 /* Find place. */
13374 while (pNext->next_sibling)
13375 {
13376 pNext = pNext->next_sibling;
13377 }
13378
13379 /* Insert node. */
13380 relax_group_list_t *pNew = bfd_malloc (sizeof (relax_group_list_t));
13381 if (!pNew)
13382 return FALSE;
13383
13384 relax_group_list_t *tmp = pNext->next_sibling;
13385 pNext->next_sibling = pNew;
13386
13387 pNew->id = -1;
13388 pNew->relo = pElem;
13389 pNew->next = NULL;
13390 pNew->next_sibling = tmp;
13391
13392 return TRUE;
13393 }
13394
13395 void
13396 dump_chain (relax_group_list_t *pHead)
13397 {
13398 relax_group_list_t *pNext = pHead->next;
13399 while (pNext)
13400 {
13401 printf("group %d @ 0x%08x", pNext->id, (unsigned)pNext->relo->r_offset);
13402 relax_group_list_t *pNextSib = pNext->next_sibling;
13403 while (pNextSib)
13404 {
13405 printf(", %d", (unsigned) ELF32_R_TYPE (pNextSib->relo->r_info));
13406 pNextSib = pNextSib->next_sibling;
13407 }
13408 pNext = pNext->next;
13409 printf("\n");
13410 }
13411 }
13412
13413 /* Check R_NDS32_RELAX_GROUP of each section.
13414 There might be multiple sections in one object file. */
13415
13416 int
13417 elf32_nds32_check_relax_group (bfd *abfd, asection *asec)
13418 {
13419 elf32_nds32_relax_group_t *relax_group_ptr =
13420 elf32_nds32_relax_group_ptr (abfd);
13421
13422 int min_id = relax_group_ptr->min_id;
13423 int max_id = relax_group_ptr->max_id;
13424
13425 Elf_Internal_Rela *rel;
13426 Elf_Internal_Rela *relend;
13427 Elf_Internal_Rela *relocs;
13428 enum elf_nds32_reloc_type rtype;
13429
13430 do
13431 {
13432 /* Relocations MUST be kept in memory, because relaxation adjust them. */
13433 relocs = _bfd_elf_link_read_relocs (abfd, asec, NULL, NULL,
13434 TRUE /* keep_memory */);
13435 if (relocs == NULL)
13436 break;
13437
13438 /* Check R_NDS32_RELAX_GROUP. */
13439 relend = relocs + asec->reloc_count;
13440 for (rel = relocs; rel < relend; rel++)
13441 {
13442 int id;
13443 rtype = ELF32_R_TYPE (rel->r_info);
13444 if (rtype != R_NDS32_RELAX_GROUP)
13445 continue;
13446
13447 id = rel->r_addend;
13448 if (id < min_id)
13449 min_id = id;
13450 else if (id > max_id)
13451 max_id = id;
13452 }
13453 }
13454 while (FALSE);
13455
13456 if ((relocs != NULL) && (elf_section_data (asec)->relocs != relocs))
13457 free (relocs);
13458
13459 if ((min_id != relax_group_ptr->min_id)
13460 || (max_id != relax_group_ptr->max_id))
13461 {
13462 relax_group_ptr->count = max_id - min_id + 1;
13463 BFD_ASSERT(min_id <= relax_group_ptr->min_id);
13464 relax_group_ptr->min_id = min_id;
13465 BFD_ASSERT(max_id >= relax_group_ptr->max_id);
13466 relax_group_ptr->max_id = max_id;
13467 }
13468
13469 return relax_group_ptr->count;
13470 }
13471
13472 /* Reorder RELAX_GROUP ID when command line option '-r' is applied. */
13473 struct section_id_list_t *relax_group_section_id_list = NULL;
13474
13475 struct section_id_list_t *
13476 elf32_nds32_lookup_section_id (int id, struct section_id_list_t **lst_ptr)
13477 {
13478 struct section_id_list_t *result = NULL;
13479 struct section_id_list_t *lst = *lst_ptr;
13480
13481 if (NULL == lst)
13482 {
13483 result = (struct section_id_list_t *) calloc
13484 (1, sizeof (struct section_id_list_t));
13485 BFD_ASSERT (result); /* Feed me. */
13486 result->id = id;
13487 *lst_ptr = result;
13488 }
13489 else
13490 {
13491 struct section_id_list_t *cur = lst;
13492 struct section_id_list_t *prv = NULL;
13493 struct section_id_list_t *sec = NULL;
13494
13495 while (cur)
13496 {
13497 if (cur->id < id)
13498 {
13499 prv = cur;
13500 cur = cur->next;
13501 continue;
13502 }
13503
13504 if (cur->id > id)
13505 {
13506 cur = NULL; /* To insert after prv. */
13507 sec = cur; /* In case prv == NULL. */
13508 }
13509
13510 break;
13511 }
13512
13513 if (NULL == cur)
13514 {
13515 /* Insert after prv. */
13516 result = (struct section_id_list_t *) calloc
13517 (1, sizeof (struct section_id_list_t));
13518 BFD_ASSERT (result); /* Feed me. */
13519 result->id = id;
13520 if (NULL != prv)
13521 {
13522 result->next = prv->next;
13523 prv->next = result;
13524 }
13525 else
13526 {
13527 *lst_ptr = result;
13528 result->next = sec;
13529 }
13530 }
13531 }
13532
13533 return result;
13534 }
13535
13536 int
13537 elf32_nds32_unify_relax_group (bfd *abfd, asection *asec)
13538 {
13539 static int next_relax_group_bias = 0;
13540
13541 elf32_nds32_relax_group_t *relax_group_ptr =
13542 elf32_nds32_relax_group_ptr (abfd);
13543
13544 bfd_boolean result = TRUE;
13545 Elf_Internal_Rela *rel;
13546 Elf_Internal_Rela *relend;
13547 Elf_Internal_Rela *relocs = NULL;
13548 enum elf_nds32_reloc_type rtype;
13549 struct section_id_list_t *node = NULL;
13550 int count = 0;
13551
13552 do
13553 {
13554 if (0 == relax_group_ptr->count)
13555 break;
13556
13557 /* Check if this section has been handled. */
13558 node = elf32_nds32_lookup_section_id (asec->id, &relax_group_section_id_list);
13559 if (NULL == node)
13560 break; /* Hit, the section id has handled. */
13561
13562 /* Relocations MUST be kept in memory, because relaxation adjust them. */
13563 relocs = _bfd_elf_link_read_relocs (abfd, asec, NULL, NULL,
13564 TRUE /* keep_memory */);
13565 if (relocs == NULL)
13566 {
13567 BFD_ASSERT (0); /* feed me */
13568 break;
13569 }
13570
13571 /* Allocate group id bias for this bfd! */
13572 if (0 == relax_group_ptr->init)
13573 {
13574 relax_group_ptr->bias = next_relax_group_bias;
13575 next_relax_group_bias += relax_group_ptr->count;
13576 relax_group_ptr->init = 1;
13577 }
13578
13579 /* Reorder relax group groups. */
13580 relend = relocs + asec->reloc_count;
13581 for (rel = relocs; rel < relend; rel++)
13582 {
13583 rtype = ELF32_R_TYPE(rel->r_info);
13584 if (rtype != R_NDS32_RELAX_GROUP)
13585 continue;
13586
13587 /* Change it. */
13588 rel->r_addend += relax_group_ptr->bias;
13589 /* Debugging count. */
13590 count++;
13591 }
13592 }
13593 while (FALSE);
13594
13595 if (relocs != NULL && elf_section_data (asec)->relocs != relocs)
13596 free (relocs);
13597
13598 return result;
13599 }
13600
13601 int
13602 nds32_elf_unify_tls_model (bfd *inbfd, asection *insec, bfd_byte *incontents,
13603 struct bfd_link_info *lnkinfo)
13604 {
13605 bfd_boolean result = TRUE;
13606 Elf_Internal_Rela *irel;
13607 Elf_Internal_Rela *irelend;
13608 Elf_Internal_Rela *internal_relocs;
13609 unsigned long r_symndx;
13610 enum elf_nds32_reloc_type r_type;
13611
13612 Elf_Internal_Sym *local_syms = NULL;
13613 bfd_byte *contents = NULL;
13614
13615 relax_group_list_t chain = { .id = -1, .next = NULL, .next_sibling = NULL };
13616
13617 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (inbfd)->symtab_hdr;
13618 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
13619 sym_hashes = elf_sym_hashes (inbfd);
13620 sym_hashes_end =
13621 sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
13622 if (!elf_bad_symtab (inbfd))
13623 sym_hashes_end -= symtab_hdr->sh_info;
13624
13625 /* Reorder RELAX_GROUP when command line option '-r' is applied. */
13626 if (bfd_link_relocatable (lnkinfo))
13627 {
13628 elf32_nds32_unify_relax_group (inbfd, insec);
13629 return result;
13630 }
13631
13632 /* Relocations MUST be kept in memory, because relaxation adjust them. */
13633 internal_relocs = _bfd_elf_link_read_relocs (inbfd, insec, NULL, NULL,
13634 TRUE /* keep_memory */);
13635 if (internal_relocs == NULL)
13636 goto error_return;
13637
13638 irelend = internal_relocs + insec->reloc_count;
13639 irel = find_relocs_at_address (internal_relocs, internal_relocs,
13640 irelend, R_NDS32_RELAX_ENTRY);
13641 if (irel == irelend)
13642 goto finish;
13643
13644 /* Chain/remove groups. */
13645 for (irel = internal_relocs; irel < irelend; irel++)
13646 {
13647 r_symndx = ELF32_R_SYM (irel->r_info);
13648 r_type = ELF32_R_TYPE (irel->r_info);
13649 if (r_type != R_NDS32_RELAX_GROUP)
13650 continue;
13651
13652 /* Remove it. */
13653 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_NONE);
13654 /* Chain it now. */
13655 if (!list_insert (&chain, irel))
13656 goto error_return;
13657 }
13658
13659 /* Collect group relocations. */
13660 /* Presume relocations are sorted. */
13661 relax_group_list_t *pNext = chain.next;
13662 while (pNext)
13663 {
13664 for (irel = internal_relocs; irel < irelend; irel++)
13665 {
13666 if (irel->r_offset == pNext->relo->r_offset)
13667 {
13668 /* Ignore Non-TLS relocation types. */
13669 r_type = ELF32_R_TYPE (irel->r_info);
13670 if ((R_NDS32_TLS_LE_HI20 > r_type)
13671 || (R_NDS32_RELAX_ENTRY == r_type))
13672 continue;
13673
13674 if (!list_insert_sibling (pNext, irel))
13675 goto error_return;
13676 }
13677 else if (irel->r_offset > pNext->relo->r_offset)
13678 {
13679 pNext = pNext->next;
13680 if (!pNext)
13681 break;
13682
13683 bfd_vma current_offset = pNext->relo->r_offset;
13684 if (irel->r_offset > current_offset)
13685 irel = internal_relocs; /* restart from head */
13686 else
13687 --irel; /* Check current irel again. */
13688 continue;
13689 }
13690 else
13691 {
13692 /* This shouldn't be reached. */
13693 }
13694 }
13695 if (pNext)
13696 pNext = pNext->next;
13697 }
13698
13699 #ifdef DUBUG_VERBOSE
13700 dump_chain(&chain);
13701 #endif
13702
13703 /* Get symbol table and section content. */
13704 if (incontents)
13705 contents = incontents;
13706 else if (!nds32_get_section_contents (inbfd, insec, &contents, TRUE)
13707 || !nds32_get_local_syms (inbfd, insec, &local_syms))
13708 goto error_return;
13709
13710 char *local_got_tls_type = elf32_nds32_local_got_tls_type (inbfd);
13711
13712 /* Convert TLS model each group if necessary. */
13713 pNext = chain.next;
13714
13715 int cur_grp_id = -1;
13716 int sethi_rt = -1;
13717 int add_rt = -1;
13718 enum elf_nds32_tls_type tls_type, org_tls_type, eff_tls_type;
13719
13720 tls_type = org_tls_type = eff_tls_type = 0;
13721
13722 while (pNext)
13723 {
13724 relax_group_list_t *pNextSig = pNext->next_sibling;
13725 while (pNextSig)
13726 {
13727 struct elf_link_hash_entry *h = NULL;
13728
13729 irel = pNextSig->relo;
13730 r_symndx = ELF32_R_SYM(irel->r_info);
13731 r_type = ELF32_R_TYPE(irel->r_info);
13732
13733 if (pNext->id != cur_grp_id)
13734 {
13735 cur_grp_id = pNext->id;
13736 org_tls_type = get_tls_type (r_type, NULL);
13737 if (r_symndx >= symtab_hdr->sh_info)
13738 {
13739 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
13740 while (h->root.type == bfd_link_hash_indirect
13741 || h->root.type == bfd_link_hash_warning)
13742 h = (struct elf_link_hash_entry *) h->root.u.i.link;
13743 tls_type = ((struct elf_nds32_link_hash_entry *) h)->tls_type;
13744 }
13745 else
13746 {
13747 tls_type = local_got_tls_type
13748 ? local_got_tls_type[r_symndx]
13749 : GOT_NORMAL;
13750 }
13751
13752 eff_tls_type = 1 << (fls (tls_type) - 1);
13753 sethi_rt = N32_RT5(bfd_getb32 (contents + irel->r_offset));
13754 }
13755
13756 if (eff_tls_type != org_tls_type)
13757 {
13758 switch (org_tls_type)
13759 {
13760 /* DESC to IEGP/IE/LE. */
13761 case GOT_TLS_DESC:
13762 switch (eff_tls_type)
13763 {
13764 case GOT_TLS_IE:
13765 switch (r_type)
13766 {
13767 case R_NDS32_TLS_DESC_HI20:
13768 irel->r_info = ELF32_R_INFO(r_symndx,
13769 R_NDS32_TLS_IE_HI20);
13770 break;
13771 case R_NDS32_TLS_DESC_LO12:
13772 irel->r_info = ELF32_R_INFO(r_symndx,
13773 R_NDS32_TLS_IE_LO12);
13774 break;
13775 case R_NDS32_TLS_DESC_ADD:
13776 {
13777 uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13778 add_rt = N32_RT5 (insn);
13779 insn = N32_TYPE2 (LWI, add_rt, sethi_rt, 0);
13780 bfd_putb32 (insn, contents + irel->r_offset);
13781
13782 irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13783 }
13784 break;
13785 case R_NDS32_TLS_DESC_FUNC:
13786 bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13787 irel->r_info = ELF32_R_INFO(r_symndx,
13788 R_NDS32_RELAX_REMOVE);
13789 break;
13790 case R_NDS32_TLS_DESC_CALL:
13791 {
13792 uint32_t insn = N32_ALU1(ADD, REG_R0, add_rt,
13793 REG_TP);
13794 bfd_putb32 (insn, contents + irel->r_offset);
13795
13796 irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13797 }
13798 break;
13799 case R_NDS32_LOADSTORE:
13800 case R_NDS32_PTR:
13801 case R_NDS32_PTR_RESOLVED:
13802 case R_NDS32_NONE:
13803 case R_NDS32_LABEL:
13804 break;
13805 default:
13806 BFD_ASSERT(0);
13807 break;
13808 }
13809 break;
13810 case GOT_TLS_IEGP:
13811 switch (r_type)
13812 {
13813 case R_NDS32_TLS_DESC_HI20:
13814 irel->r_info = ELF32_R_INFO(r_symndx,
13815 R_NDS32_TLS_IEGP_HI20);
13816 break;
13817 case R_NDS32_TLS_DESC_LO12:
13818 irel->r_info = ELF32_R_INFO(r_symndx,
13819 R_NDS32_TLS_IEGP_LO12);
13820 break;
13821 case R_NDS32_TLS_DESC_ADD:
13822 {
13823 uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13824 add_rt = N32_RT5 (insn);
13825 insn = N32_MEM(LW, add_rt, sethi_rt, REG_GP, 0);
13826 bfd_putb32 (insn, contents + irel->r_offset);
13827
13828 irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13829 }
13830 break;
13831 case R_NDS32_TLS_DESC_FUNC:
13832 bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13833 irel->r_info = ELF32_R_INFO(r_symndx,
13834 R_NDS32_RELAX_REMOVE);
13835 break;
13836 case R_NDS32_TLS_DESC_CALL:
13837 {
13838 uint32_t insn = N32_ALU1(ADD, REG_R0, add_rt,
13839 REG_TP);
13840 bfd_putb32 (insn, contents + irel->r_offset);
13841
13842 irel->r_info = ELF32_R_INFO(r_symndx, R_NDS32_NONE);
13843 }
13844 break;
13845 case R_NDS32_LOADSTORE:
13846 case R_NDS32_PTR:
13847 case R_NDS32_PTR_RESOLVED:
13848 case R_NDS32_NONE:
13849 case R_NDS32_LABEL:
13850 break;
13851 default:
13852 BFD_ASSERT(0);
13853 break;
13854 }
13855 break;
13856 case GOT_TLS_LE:
13857 switch (r_type)
13858 {
13859 case R_NDS32_TLS_DESC_HI20:
13860 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_HI20);
13861 break;
13862 case R_NDS32_TLS_DESC_LO12:
13863 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_LO12);
13864 break;
13865 case R_NDS32_TLS_DESC_ADD:
13866 {
13867 uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13868
13869 add_rt = N32_RT5 (insn);
13870 insn = N32_ALU1 (ADD, REG_R0, sethi_rt, REG_TP);
13871 bfd_putb32 (insn, contents + irel->r_offset);
13872
13873 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_ADD);
13874 }
13875 break;
13876 case R_NDS32_TLS_DESC_FUNC:
13877 bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13878 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_RELAX_REMOVE);
13879 break;
13880 case R_NDS32_TLS_DESC_CALL:
13881 bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13882 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_RELAX_REMOVE);
13883 break;
13884 case R_NDS32_LOADSTORE:
13885 case R_NDS32_PTR:
13886 case R_NDS32_PTR_RESOLVED:
13887 case R_NDS32_NONE:
13888 case R_NDS32_LABEL:
13889 break;
13890 default:
13891 BFD_ASSERT(0);
13892 break;
13893 }
13894 break;
13895 default:
13896 break;
13897 }
13898 break;
13899 /* IEGP to IE/LE. */
13900 case GOT_TLS_IEGP:
13901 switch (eff_tls_type)
13902 {
13903 case GOT_TLS_IE:
13904 switch (r_type)
13905 {
13906 case R_NDS32_TLS_IEGP_HI20:
13907 irel->r_info = ELF32_R_INFO(r_symndx,
13908 R_NDS32_TLS_IE_HI20);
13909 break;
13910 case R_NDS32_TLS_IEGP_LO12:
13911 irel->r_info = ELF32_R_INFO(r_symndx,
13912 R_NDS32_TLS_IE_LO12);
13913 break;
13914 case R_NDS32_PTR_RESOLVED:
13915 {
13916 uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13917
13918 add_rt = N32_RT5 (insn);
13919 insn = N32_TYPE2 (LWI, add_rt, sethi_rt, 0);
13920 bfd_putb32 (insn, contents + irel->r_offset);
13921 }
13922 break;
13923 case R_NDS32_TLS_IEGP_LW:
13924 break;
13925 case R_NDS32_LOADSTORE:
13926 case R_NDS32_PTR:
13927 case R_NDS32_NONE:
13928 case R_NDS32_LABEL:
13929 break;
13930 default:
13931 BFD_ASSERT(0);
13932 break;
13933 }
13934 break;
13935 case GOT_TLS_LE:
13936 switch (r_type)
13937 {
13938 case R_NDS32_TLS_IEGP_HI20:
13939 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_HI20);
13940 break;
13941 case R_NDS32_TLS_IEGP_LO12:
13942 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_LO12);
13943 break;
13944 case R_NDS32_TLS_IEGP_LW:
13945 bfd_putb32 (INSN_NOP, contents + irel->r_offset);
13946 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_RELAX_REMOVE);
13947 break;
13948 case R_NDS32_LOADSTORE:
13949 case R_NDS32_PTR:
13950 case R_NDS32_NONE:
13951 case R_NDS32_LABEL:
13952 case R_NDS32_PTR_RESOLVED:
13953 break;
13954 default:
13955 BFD_ASSERT(0);
13956 break;
13957 }
13958 break;
13959 default:
13960 break;
13961 }
13962 break;
13963 /* IE to LE. */
13964 case GOT_TLS_IE:
13965 switch (eff_tls_type)
13966 {
13967 case GOT_TLS_LE:
13968 switch (r_type)
13969 {
13970 case R_NDS32_TLS_IE_HI20:
13971 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_HI20);
13972 break;
13973 case R_NDS32_TLS_IE_LO12S2:
13974 {
13975 uint32_t insn = bfd_getb32 (contents + irel->r_offset);
13976
13977 add_rt = N32_RT5 (insn);
13978 insn = N32_TYPE2 (ORI, add_rt, sethi_rt, 0);
13979 bfd_putb32 (insn, contents + irel->r_offset);
13980
13981 irel->r_info = ELF32_R_INFO (r_symndx, R_NDS32_TLS_LE_LO12);
13982 }
13983 break;
13984 case R_NDS32_LOADSTORE:
13985 case R_NDS32_PTR:
13986 case R_NDS32_NONE:
13987 case R_NDS32_LABEL:
13988 break;
13989 default:
13990 BFD_ASSERT(0);
13991 break;
13992 }
13993 break;
13994 default:
13995 break;
13996 }
13997 break;
13998 default:
13999 break;
14000 }
14001 }
14002 pNextSig = pNextSig->next_sibling;
14003 }
14004
14005 #if 1
14006 pNext = pNext->next;
14007 #else
14008 while (pNext)
14009 {
14010 if (pNext->id != cur_grp_id)
14011 break;
14012 pNext = pNext->next;
14013 }
14014 #endif
14015 }
14016
14017 finish:
14018 if (incontents)
14019 contents = NULL;
14020
14021 if (internal_relocs != NULL
14022 && elf_section_data (insec)->relocs != internal_relocs)
14023 free (internal_relocs);
14024
14025 if (contents != NULL
14026 && elf_section_data (insec)->this_hdr.contents != contents)
14027 free (contents);
14028
14029 if (local_syms != NULL && symtab_hdr->contents != (bfd_byte *) local_syms)
14030 free (local_syms);
14031
14032 if (chain.next)
14033 {
14034 pNext = chain.next;
14035 relax_group_list_t *pDel;
14036 while (pNext)
14037 {
14038 pDel = pNext;
14039 pNext = pNext->next;
14040 free (pDel);
14041 }
14042 }
14043
14044 return result;
14045
14046 error_return:
14047 result = FALSE;
14048 goto finish;
14049 }
14050
14051 /* End TLS model conversion. */
14052
14053 #define ELF_ARCH bfd_arch_nds32
14054 #define ELF_MACHINE_CODE EM_NDS32
14055 #define ELF_MAXPAGESIZE 0x1000
14056 #define ELF_TARGET_ID NDS32_ELF_DATA
14057
14058 #define TARGET_BIG_SYM nds32_elf32_be_vec
14059 #define TARGET_BIG_NAME "elf32-nds32be"
14060 #define TARGET_LITTLE_SYM nds32_elf32_le_vec
14061 #define TARGET_LITTLE_NAME "elf32-nds32le"
14062
14063 #define elf_info_to_howto nds32_info_to_howto
14064 #define elf_info_to_howto_rel nds32_info_to_howto_rel
14065
14066 #define bfd_elf32_bfd_link_hash_table_create nds32_elf_link_hash_table_create
14067 #define bfd_elf32_bfd_merge_private_bfd_data nds32_elf_merge_private_bfd_data
14068 #define bfd_elf32_bfd_print_private_bfd_data nds32_elf_print_private_bfd_data
14069 #define bfd_elf32_bfd_relax_section nds32_elf_relax_section
14070 #define bfd_elf32_bfd_set_private_flags nds32_elf_set_private_flags
14071
14072 #define bfd_elf32_mkobject nds32_elf_mkobject
14073 #define elf_backend_action_discarded nds32_elf_action_discarded
14074 #define elf_backend_add_symbol_hook nds32_elf_add_symbol_hook
14075 #define elf_backend_check_relocs nds32_elf_check_relocs
14076 #define elf_backend_adjust_dynamic_symbol nds32_elf_adjust_dynamic_symbol
14077 #define elf_backend_create_dynamic_sections nds32_elf_create_dynamic_sections
14078 #define elf_backend_finish_dynamic_sections nds32_elf_finish_dynamic_sections
14079 #define elf_backend_finish_dynamic_symbol nds32_elf_finish_dynamic_symbol
14080 #define elf_backend_size_dynamic_sections nds32_elf_size_dynamic_sections
14081 #define elf_backend_relocate_section nds32_elf_relocate_section
14082 #define elf_backend_gc_mark_hook nds32_elf_gc_mark_hook
14083 #define elf_backend_grok_prstatus nds32_elf_grok_prstatus
14084 #define elf_backend_grok_psinfo nds32_elf_grok_psinfo
14085 #define elf_backend_reloc_type_class nds32_elf_reloc_type_class
14086 #define elf_backend_copy_indirect_symbol nds32_elf_copy_indirect_symbol
14087 #define elf_backend_link_output_symbol_hook nds32_elf_output_symbol_hook
14088 #define elf_backend_output_arch_syms nds32_elf_output_arch_syms
14089 #define elf_backend_object_p nds32_elf_object_p
14090 #define elf_backend_final_write_processing nds32_elf_final_write_processing
14091 #define elf_backend_special_sections nds32_elf_special_sections
14092 #define bfd_elf32_bfd_get_relocated_section_contents \
14093 nds32_elf_get_relocated_section_contents
14094 #define bfd_elf32_bfd_is_target_special_symbol nds32_elf_is_target_special_symbol
14095 #define elf_backend_maybe_function_sym nds32_elf_maybe_function_sym
14096
14097 #define elf_backend_can_gc_sections 1
14098 #define elf_backend_can_refcount 1
14099 #define elf_backend_want_got_plt 1
14100 #define elf_backend_plt_readonly 1
14101 #define elf_backend_want_plt_sym 0
14102 #define elf_backend_got_header_size 12
14103 #define elf_backend_may_use_rel_p 1
14104 #define elf_backend_default_use_rela_p 1
14105 #define elf_backend_may_use_rela_p 1
14106 #define elf_backend_dtrel_excludes_plt 0
14107
14108 #include "elf32-target.h"
14109
14110 #undef ELF_MAXPAGESIZE
14111 #define ELF_MAXPAGESIZE 0x2000
14112
14113 #undef TARGET_BIG_SYM
14114 #define TARGET_BIG_SYM nds32_elf32_linux_be_vec
14115 #undef TARGET_BIG_NAME
14116 #define TARGET_BIG_NAME "elf32-nds32be-linux"
14117 #undef TARGET_LITTLE_SYM
14118 #define TARGET_LITTLE_SYM nds32_elf32_linux_le_vec
14119 #undef TARGET_LITTLE_NAME
14120 #define TARGET_LITTLE_NAME "elf32-nds32le-linux"
14121 #undef elf32_bed
14122 #define elf32_bed elf32_nds32_lin_bed
14123
14124 #include "elf32-target.h"
The GNU Binutils are a collection of binary tools.