projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
NDS32/BFD: Correct an aliasing error in `nds32_elf_check_relocs'
[binutils-gdb.git] / bfd / elf32-nds32.c
1 /* NDS32-specific support for 32-bit ELF.
2 Copyright (C) 2012-2016 Free Software Foundation, Inc.
3 Contributed by Andes Technology Corporation.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "bfd_stdint.h"
26 #include "bfdlink.h"
27 #include "libbfd.h"
28 #include "elf-bfd.h"
29 #include "libiberty.h"
30 #include "bfd_stdint.h"
31 #include "elf/nds32.h"
32 #include "opcode/nds32.h"
33 #include "elf32-nds32.h"
34 #include "opcode/cgen.h"
35 #include "../opcodes/nds32-opc.h"
36
37 /* Relocation HOWTO functions. */
38 static bfd_reloc_status_type nds32_elf_ignore_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type nds32_elf_9_pcrel_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type nds32_elf_hi20_reloc
43 (bfd *, arelent *, asymbol *, void *,
44 asection *, bfd *, char **);
45 static bfd_reloc_status_type nds32_elf_lo12_reloc
46 (bfd *, arelent *, asymbol *, void *,
47 asection *, bfd *, char **);
48 static bfd_reloc_status_type nds32_elf_generic_reloc
49 (bfd *, arelent *, asymbol *, void *,
50 asection *, bfd *, char **);
51 static bfd_reloc_status_type nds32_elf_sda15_reloc
52 (bfd *, arelent *, asymbol *, void *,
53 asection *, bfd *, char **);
54
55 /* Helper functions for HOWTO. */
56 static bfd_reloc_status_type nds32_elf_do_9_pcrel_reloc
57 (bfd *, reloc_howto_type *, asection *, bfd_byte *, bfd_vma,
58 asection *, bfd_vma, bfd_vma);
59 static void nds32_elf_relocate_hi20
60 (bfd *, int, Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_byte *, bfd_vma);
61 static reloc_howto_type *bfd_elf32_bfd_reloc_type_table_lookup
62 (enum elf_nds32_reloc_type);
63 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
64 (bfd *, bfd_reloc_code_real_type);
65
66 /* Target hooks. */
67 static void nds32_info_to_howto_rel
68 (bfd *, arelent *, Elf_Internal_Rela *dst);
69 static void nds32_info_to_howto
70 (bfd *, arelent *, Elf_Internal_Rela *dst);
71 static bfd_boolean nds32_elf_add_symbol_hook
72 (bfd *, struct bfd_link_info *, Elf_Internal_Sym *, const char **,
73 flagword *, asection **, bfd_vma *);
74 static bfd_boolean nds32_elf_relocate_section
75 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
76 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
77 static bfd_boolean nds32_elf_object_p (bfd *);
78 static void nds32_elf_final_write_processing (bfd *, bfd_boolean);
79 static bfd_boolean nds32_elf_set_private_flags (bfd *, flagword);
80 static bfd_boolean nds32_elf_merge_private_bfd_data
81 (bfd *, struct bfd_link_info *);
82 static bfd_boolean nds32_elf_print_private_bfd_data (bfd *, void *);
83 static bfd_boolean nds32_elf_gc_sweep_hook
84 (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
85 static bfd_boolean nds32_elf_check_relocs
86 (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
87 static asection *nds32_elf_gc_mark_hook
88 (asection *, struct bfd_link_info *, Elf_Internal_Rela *,
89 struct elf_link_hash_entry *, Elf_Internal_Sym *);
90 static bfd_boolean nds32_elf_adjust_dynamic_symbol
91 (struct bfd_link_info *, struct elf_link_hash_entry *);
92 static bfd_boolean nds32_elf_size_dynamic_sections
93 (bfd *, struct bfd_link_info *);
94 static bfd_boolean nds32_elf_create_dynamic_sections
95 (bfd *, struct bfd_link_info *);
96 static bfd_boolean nds32_elf_finish_dynamic_sections
97 (bfd *, struct bfd_link_info *info);
98 static bfd_boolean nds32_elf_finish_dynamic_symbol
99 (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
100 Elf_Internal_Sym *);
101 static bfd_boolean nds32_elf_mkobject (bfd *);
102
103 /* Nds32 helper functions. */
104 static bfd_reloc_status_type nds32_elf_final_sda_base
105 (bfd *, struct bfd_link_info *, bfd_vma *, bfd_boolean);
106 static bfd_boolean allocate_dynrelocs (struct elf_link_hash_entry *, void *);
107 static bfd_boolean readonly_dynrelocs (struct elf_link_hash_entry *, void *);
108 static Elf_Internal_Rela *find_relocs_at_address
109 (Elf_Internal_Rela *, Elf_Internal_Rela *,
110 Elf_Internal_Rela *, enum elf_nds32_reloc_type);
111 static bfd_vma calculate_memory_address
112 (bfd *, Elf_Internal_Rela *, Elf_Internal_Sym *, Elf_Internal_Shdr *);
113 static int nds32_get_section_contents (bfd *, asection *,
114 bfd_byte **, bfd_boolean);
115 static bfd_boolean nds32_elf_ex9_build_hash_table
116 (bfd *, asection *, struct bfd_link_info *);
117 static bfd_boolean nds32_elf_ex9_itb_base (struct bfd_link_info *);
118 static void nds32_elf_ex9_import_table (struct bfd_link_info *);
119 static void nds32_elf_ex9_finish (struct bfd_link_info *);
120 static void nds32_elf_ex9_reloc_jmp (struct bfd_link_info *);
121 static void nds32_elf_get_insn_with_reg
122 (Elf_Internal_Rela *, uint32_t, uint32_t *);
123 static int nds32_get_local_syms (bfd *, asection *ATTRIBUTE_UNUSED,
124 Elf_Internal_Sym **);
125 static bfd_boolean nds32_elf_ex9_replace_instruction
126 (struct bfd_link_info *, bfd *, asection *);
127 static bfd_boolean nds32_elf_ifc_calc (struct bfd_link_info *, bfd *,
128 asection *);
129 static bfd_boolean nds32_elf_ifc_finish (struct bfd_link_info *);
130 static bfd_boolean nds32_elf_ifc_replace (struct bfd_link_info *);
131 static bfd_boolean nds32_elf_ifc_reloc (void);
132 static bfd_boolean nds32_relax_fp_as_gp
133 (struct bfd_link_info *link_info, bfd *abfd, asection *sec,
134 Elf_Internal_Rela *internal_relocs, Elf_Internal_Rela *irelend,
135 Elf_Internal_Sym *isymbuf);
136 static bfd_boolean nds32_fag_remove_unused_fpbase
137 (bfd *abfd, asection *sec, Elf_Internal_Rela *internal_relocs,
138 Elf_Internal_Rela *irelend);
139 static bfd_byte *
140 nds32_elf_get_relocated_section_contents (bfd *abfd,
141 struct bfd_link_info *link_info,
142 struct bfd_link_order *link_order,
143 bfd_byte *data,
144 bfd_boolean relocatable,
145 asymbol **symbols);
146
147 enum
148 {
149 MACH_V1 = bfd_mach_n1h,
150 MACH_V2 = bfd_mach_n1h_v2,
151 MACH_V3 = bfd_mach_n1h_v3,
152 MACH_V3M = bfd_mach_n1h_v3m
153 };
154
155 #define MIN(a, b) ((a) > (b) ? (b) : (a))
156 #define MAX(a, b) ((a) > (b) ? (a) : (b))
157
158 /* The name of the dynamic interpreter. This is put in the .interp
159 section. */
160 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
161
162 /* The nop opcode we use. */
163 #define NDS32_NOP32 0x40000009
164 #define NDS32_NOP16 0x9200
165
166 /* The size in bytes of an entry in the procedure linkage table. */
167 #define PLT_ENTRY_SIZE 24
168 #define PLT_HEADER_SIZE 24
169
170 /* The first entry in a procedure linkage table are reserved,
171 and the initial contents are unimportant (we zero them out).
172 Subsequent entries look like this. */
173 #define PLT0_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(.got+4) */
174 #define PLT0_ENTRY_WORD1 0x58f78000 /* ori r15, r25, LO12(.got+4) */
175 #define PLT0_ENTRY_WORD2 0x05178000 /* lwi r17, [r15+0] */
176 #define PLT0_ENTRY_WORD3 0x04f78001 /* lwi r15, [r15+4] */
177 #define PLT0_ENTRY_WORD4 0x4a003c00 /* jr r15 */
178
179 /* $ta is change to $r15 (from $r25). */
180 #define PLT0_PIC_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(got[1]@GOT) */
181 #define PLT0_PIC_ENTRY_WORD1 0x58f78000 /* ori r15, r15, LO12(got[1]@GOT) */
182 #define PLT0_PIC_ENTRY_WORD2 0x40f7f400 /* add r15, gp, r15 */
183 #define PLT0_PIC_ENTRY_WORD3 0x05178000 /* lwi r17, [r15+0] */
184 #define PLT0_PIC_ENTRY_WORD4 0x04f78001 /* lwi r15, [r15+4] */
185 #define PLT0_PIC_ENTRY_WORD5 0x4a003c00 /* jr r15 */
186
187 #define PLT_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(&got[n+3]) */
188 #define PLT_ENTRY_WORD1 0x04f78000 /* lwi r15, r15, LO12(&got[n+3]) */
189 #define PLT_ENTRY_WORD2 0x4a003c00 /* jr r15 */
190 #define PLT_ENTRY_WORD3 0x45000000 /* movi r16, sizeof(RELA) * n */
191 #define PLT_ENTRY_WORD4 0x48000000 /* j .plt0. */
192
193 #define PLT_PIC_ENTRY_WORD0 0x46f00000 /* sethi r15, HI20(got[n+3]@GOT) */
194 #define PLT_PIC_ENTRY_WORD1 0x58f78000 /* ori r15, r15, LO12(got[n+3]@GOT) */
195 #define PLT_PIC_ENTRY_WORD2 0x38febc02 /* lw r15, [gp+r15] */
196 #define PLT_PIC_ENTRY_WORD3 0x4a003c00 /* jr r15 */
197 #define PLT_PIC_ENTRY_WORD4 0x45000000 /* movi r16, sizeof(RELA) * n */
198 #define PLT_PIC_ENTRY_WORD5 0x48000000 /* j .plt0 */
199
200 /* These are macros used to get the relocation accurate value. */
201 #define ACCURATE_8BIT_S1 (0x100)
202 #define ACCURATE_U9BIT_S1 (0x400)
203 #define ACCURATE_12BIT_S1 (0x2000)
204 #define ACCURATE_14BIT_S1 (0x4000)
205 #define ACCURATE_19BIT (0x40000)
206
207 /* These are macros used to get the relocation conservative value. */
208 #define CONSERVATIVE_8BIT_S1 (0x100 - 4)
209 #define CONSERVATIVE_14BIT_S1 (0x4000 - 4)
210 #define CONSERVATIVE_16BIT_S1 (0x10000 - 4)
211 #define CONSERVATIVE_24BIT_S1 (0x1000000 - 4)
212 /* These must be more conservative because the address may be in
213 different segment. */
214 #define CONSERVATIVE_15BIT (0x4000 - 0x1000)
215 #define CONSERVATIVE_15BIT_S1 (0x8000 - 0x1000)
216 #define CONSERVATIVE_15BIT_S2 (0x10000 - 0x1000)
217 #define CONSERVATIVE_19BIT (0x40000 - 0x1000)
218 #define CONSERVATIVE_20BIT (0x80000 - 0x1000)
219
220 /* Size of small data/bss sections, used to calculate SDA_BASE. */
221 static long got_size = 0;
222 static int is_SDA_BASE_set = 0;
223 static int is_ITB_BASE_set = 0;
224
225 /* Convert ELF-VER in eflags to string for debugging purpose. */
226 static const char *const nds32_elfver_strtab[] =
227 {
228 "ELF-1.2",
229 "ELF-1.3",
230 "ELF-1.4",
231 };
232
233 /* The nds32 linker needs to keep track of the number of relocs that it
234 decides to copy in check_relocs for each symbol. This is so that
235 it can discard PC relative relocs if it doesn't need them when
236 linking with -Bsymbolic. We store the information in a field
237 extending the regular ELF linker hash table. */
238
239 /* This structure keeps track of the number of PC relative relocs we
240 have copied for a given symbol. */
241
242 struct elf_nds32_pcrel_relocs_copied
243 {
244 /* Next section. */
245 struct elf_nds32_pcrel_relocs_copied *next;
246 /* A section in dynobj. */
247 asection *section;
248 /* Number of relocs copied in this section. */
249 bfd_size_type count;
250 };
251
252 /* The sh linker needs to keep track of the number of relocs that it
253 decides to copy as dynamic relocs in check_relocs for each symbol.
254 This is so that it can later discard them if they are found to be
255 unnecessary. We store the information in a field extending the
256 regular ELF linker hash table. */
257
258 struct elf_nds32_dyn_relocs
259 {
260 struct elf_nds32_dyn_relocs *next;
261
262 /* The input section of the reloc. */
263 asection *sec;
264
265 /* Total number of relocs copied for the input section. */
266 bfd_size_type count;
267
268 /* Number of pc-relative relocs copied for the input section. */
269 bfd_size_type pc_count;
270 };
271
272 /* Nds32 ELF linker hash entry. */
273
274 struct elf_nds32_link_hash_entry
275 {
276 struct elf_link_hash_entry root;
277
278 /* Track dynamic relocs copied for this symbol. */
279 struct elf_nds32_dyn_relocs *dyn_relocs;
280
281 /* For checking relocation type. */
282 #define GOT_UNKNOWN 0
283 #define GOT_NORMAL 1
284 #define GOT_TLS_IE 2
285 unsigned int tls_type;
286 };
287
288 /* Get the nds32 ELF linker hash table from a link_info structure. */
289
290 #define FP_BASE_NAME "_FP_BASE_"
291 static int check_start_export_sym = 0;
292 static size_t ex9_relax_size = 0; /* Save ex9 predicted reducing size. */
293
294 /* The offset for executable tls relaxation. */
295 #define TP_OFFSET 0x0
296
297 struct elf_nds32_obj_tdata
298 {
299 struct elf_obj_tdata root;
300
301 /* tls_type for each local got entry. */
302 char *local_got_tls_type;
303 };
304
305 #define elf_nds32_tdata(bfd) \
306 ((struct elf_nds32_obj_tdata *) (bfd)->tdata.any)
307
308 #define elf32_nds32_local_got_tls_type(bfd) \
309 (elf_nds32_tdata (bfd)->local_got_tls_type)
310
311 #define elf32_nds32_hash_entry(ent) ((struct elf_nds32_link_hash_entry *)(ent))
312
313 static bfd_boolean
314 nds32_elf_mkobject (bfd *abfd)
315 {
316 return bfd_elf_allocate_object (abfd, sizeof (struct elf_nds32_obj_tdata),
317 NDS32_ELF_DATA);
318 }
319
320 /* Relocations used for relocation. */
321 static reloc_howto_type nds32_elf_howto_table[] =
322 {
323 /* This reloc does nothing. */
324 HOWTO (R_NDS32_NONE, /* type */
325 0, /* rightshift */
326 3, /* size (0 = byte, 1 = short, 2 = long) */
327 0, /* bitsize */
328 FALSE, /* pc_relative */
329 0, /* bitpos */
330 complain_overflow_dont, /* complain_on_overflow */
331 bfd_elf_generic_reloc, /* special_function */
332 "R_NDS32_NONE", /* name */
333 FALSE, /* partial_inplace */
334 0, /* src_mask */
335 0, /* dst_mask */
336 FALSE), /* pcrel_offset */
337
338 /* A 16 bit absolute relocation. */
339 HOWTO (R_NDS32_16, /* type */
340 0, /* rightshift */
341 1, /* size (0 = byte, 1 = short, 2 = long) */
342 16, /* bitsize */
343 FALSE, /* pc_relative */
344 0, /* bitpos */
345 complain_overflow_bitfield, /* complain_on_overflow */
346 nds32_elf_generic_reloc, /* special_function */
347 "R_NDS32_16", /* name */
348 FALSE, /* partial_inplace */
349 0xffff, /* src_mask */
350 0xffff, /* dst_mask */
351 FALSE), /* pcrel_offset */
352
353 /* A 32 bit absolute relocation. */
354 HOWTO (R_NDS32_32, /* type */
355 0, /* rightshift */
356 2, /* size (0 = byte, 1 = short, 2 = long) */
357 32, /* bitsize */
358 FALSE, /* pc_relative */
359 0, /* bitpos */
360 complain_overflow_bitfield, /* complain_on_overflow */
361 nds32_elf_generic_reloc, /* special_function */
362 "R_NDS32_32", /* name */
363 FALSE, /* partial_inplace */
364 0xffffffff, /* src_mask */
365 0xffffffff, /* dst_mask */
366 FALSE), /* pcrel_offset */
367
368 /* A 20 bit address. */
369 HOWTO (R_NDS32_20, /* type */
370 0, /* rightshift */
371 2, /* size (0 = byte, 1 = short, 2 = long) */
372 20, /* bitsize */
373 FALSE, /* pc_relative */
374 0, /* bitpos */
375 complain_overflow_unsigned, /* complain_on_overflow */
376 nds32_elf_generic_reloc, /* special_function */
377 "R_NDS32_20", /* name */
378 FALSE, /* partial_inplace */
379 0xfffff, /* src_mask */
380 0xfffff, /* dst_mask */
381 FALSE), /* pcrel_offset */
382
383 /* An PC Relative 9-bit relocation, shifted by 2.
384 This reloc is complicated because relocations are relative to pc & -4.
385 i.e. branches in the right insn slot use the address of the left insn
386 slot for pc. */
387 /* ??? It's not clear whether this should have partial_inplace set or not.
388 Branch relaxing in the assembler can store the addend in the insn,
389 and if bfd_install_relocation gets called the addend may get added
390 again. */
391 HOWTO (R_NDS32_9_PCREL, /* type */
392 1, /* rightshift */
393 1, /* size (0 = byte, 1 = short, 2 = long) */
394 8, /* bitsize */
395 TRUE, /* pc_relative */
396 0, /* bitpos */
397 complain_overflow_signed, /* complain_on_overflow */
398 nds32_elf_9_pcrel_reloc, /* special_function */
399 "R_NDS32_9_PCREL", /* name */
400 FALSE, /* partial_inplace */
401 0xff, /* src_mask */
402 0xff, /* dst_mask */
403 TRUE), /* pcrel_offset */
404
405 /* A relative 15 bit relocation, right shifted by 1. */
406 HOWTO (R_NDS32_15_PCREL, /* type */
407 1, /* rightshift */
408 2, /* size (0 = byte, 1 = short, 2 = long) */
409 14, /* bitsize */
410 TRUE, /* pc_relative */
411 0, /* bitpos */
412 complain_overflow_signed, /* complain_on_overflow */
413 bfd_elf_generic_reloc, /* special_function */
414 "R_NDS32_15_PCREL", /* name */
415 FALSE, /* partial_inplace */
416 0x3fff, /* src_mask */
417 0x3fff, /* dst_mask */
418 TRUE), /* pcrel_offset */
419
420 /* A relative 17 bit relocation, right shifted by 1. */
421 HOWTO (R_NDS32_17_PCREL, /* type */
422 1, /* rightshift */
423 2, /* size (0 = byte, 1 = short, 2 = long) */
424 16, /* bitsize */
425 TRUE, /* pc_relative */
426 0, /* bitpos */
427 complain_overflow_signed, /* complain_on_overflow */
428 bfd_elf_generic_reloc, /* special_function */
429 "R_NDS32_17_PCREL", /* name */
430 FALSE, /* partial_inplace */
431 0xffff, /* src_mask */
432 0xffff, /* dst_mask */
433 TRUE), /* pcrel_offset */
434
435 /* A relative 25 bit relocation, right shifted by 1. */
436 /* ??? It's not clear whether this should have partial_inplace set or not.
437 Branch relaxing in the assembler can store the addend in the insn,
438 and if bfd_install_relocation gets called the addend may get added
439 again. */
440 HOWTO (R_NDS32_25_PCREL, /* type */
441 1, /* rightshift */
442 2, /* size (0 = byte, 1 = short, 2 = long) */
443 24, /* bitsize */
444 TRUE, /* pc_relative */
445 0, /* bitpos */
446 complain_overflow_signed, /* complain_on_overflow */
447 bfd_elf_generic_reloc, /* special_function */
448 "R_NDS32_25_PCREL", /* name */
449 FALSE, /* partial_inplace */
450 0xffffff, /* src_mask */
451 0xffffff, /* dst_mask */
452 TRUE), /* pcrel_offset */
453
454 /* High 20 bits of address when lower 12 is or'd in. */
455 HOWTO (R_NDS32_HI20, /* type */
456 12, /* rightshift */
457 2, /* size (0 = byte, 1 = short, 2 = long) */
458 20, /* bitsize */
459 FALSE, /* pc_relative */
460 0, /* bitpos */
461 complain_overflow_dont,/* complain_on_overflow */
462 nds32_elf_hi20_reloc, /* special_function */
463 "R_NDS32_HI20", /* name */
464 FALSE, /* partial_inplace */
465 0x000fffff, /* src_mask */
466 0x000fffff, /* dst_mask */
467 FALSE), /* pcrel_offset */
468
469 /* Lower 12 bits of address. */
470 HOWTO (R_NDS32_LO12S3, /* type */
471 3, /* rightshift */
472 2, /* size (0 = byte, 1 = short, 2 = long) */
473 9, /* bitsize */
474 FALSE, /* pc_relative */
475 0, /* bitpos */
476 complain_overflow_dont,/* complain_on_overflow */
477 nds32_elf_lo12_reloc, /* special_function */
478 "R_NDS32_LO12S3", /* name */
479 FALSE, /* partial_inplace */
480 0x000001ff, /* src_mask */
481 0x000001ff, /* dst_mask */
482 FALSE), /* pcrel_offset */
483
484 /* Lower 12 bits of address. */
485 HOWTO (R_NDS32_LO12S2, /* type */
486 2, /* rightshift */
487 2, /* size (0 = byte, 1 = short, 2 = long) */
488 10, /* bitsize */
489 FALSE, /* pc_relative */
490 0, /* bitpos */
491 complain_overflow_dont,/* complain_on_overflow */
492 nds32_elf_lo12_reloc, /* special_function */
493 "R_NDS32_LO12S2", /* name */
494 FALSE, /* partial_inplace */
495 0x000003ff, /* src_mask */
496 0x000003ff, /* dst_mask */
497 FALSE), /* pcrel_offset */
498
499 /* Lower 12 bits of address. */
500 HOWTO (R_NDS32_LO12S1, /* type */
501 1, /* rightshift */
502 2, /* size (0 = byte, 1 = short, 2 = long) */
503 11, /* bitsize */
504 FALSE, /* pc_relative */
505 0, /* bitpos */
506 complain_overflow_dont,/* complain_on_overflow */
507 nds32_elf_lo12_reloc, /* special_function */
508 "R_NDS32_LO12S1", /* name */
509 FALSE, /* partial_inplace */
510 0x000007ff, /* src_mask */
511 0x000007ff, /* dst_mask */
512 FALSE), /* pcrel_offset */
513
514 /* Lower 12 bits of address. */
515 HOWTO (R_NDS32_LO12S0, /* type */
516 0, /* rightshift */
517 2, /* size (0 = byte, 1 = short, 2 = long) */
518 12, /* bitsize */
519 FALSE, /* pc_relative */
520 0, /* bitpos */
521 complain_overflow_dont,/* complain_on_overflow */
522 nds32_elf_lo12_reloc, /* special_function */
523 "R_NDS32_LO12S0", /* name */
524 FALSE, /* partial_inplace */
525 0x00000fff, /* src_mask */
526 0x00000fff, /* dst_mask */
527 FALSE), /* pcrel_offset */
528
529 /* Small data area 15 bits offset. */
530 HOWTO (R_NDS32_SDA15S3, /* type */
531 3, /* rightshift */
532 2, /* size (0 = byte, 1 = short, 2 = long) */
533 15, /* bitsize */
534 FALSE, /* pc_relative */
535 0, /* bitpos */
536 complain_overflow_signed, /* complain_on_overflow */
537 nds32_elf_sda15_reloc, /* special_function */
538 "R_NDS32_SDA15S3", /* name */
539 FALSE, /* partial_inplace */
540 0x00007fff, /* src_mask */
541 0x00007fff, /* dst_mask */
542 FALSE), /* pcrel_offset */
543
544 /* Small data area 15 bits offset. */
545 HOWTO (R_NDS32_SDA15S2, /* type */
546 2, /* rightshift */
547 2, /* size (0 = byte, 1 = short, 2 = long) */
548 15, /* bitsize */
549 FALSE, /* pc_relative */
550 0, /* bitpos */
551 complain_overflow_signed, /* complain_on_overflow */
552 nds32_elf_sda15_reloc, /* special_function */
553 "R_NDS32_SDA15S2", /* name */
554 FALSE, /* partial_inplace */
555 0x00007fff, /* src_mask */
556 0x00007fff, /* dst_mask */
557 FALSE), /* pcrel_offset */
558
559 /* Small data area 15 bits offset. */
560 HOWTO (R_NDS32_SDA15S1, /* type */
561 1, /* rightshift */
562 2, /* size (0 = byte, 1 = short, 2 = long) */
563 15, /* bitsize */
564 FALSE, /* pc_relative */
565 0, /* bitpos */
566 complain_overflow_signed, /* complain_on_overflow */
567 nds32_elf_sda15_reloc, /* special_function */
568 "R_NDS32_SDA15S1", /* name */
569 FALSE, /* partial_inplace */
570 0x00007fff, /* src_mask */
571 0x00007fff, /* dst_mask */
572 FALSE), /* pcrel_offset */
573
574 /* Small data area 15 bits offset. */
575 HOWTO (R_NDS32_SDA15S0, /* type */
576 0, /* rightshift */
577 2, /* size (0 = byte, 1 = short, 2 = long) */
578 15, /* bitsize */
579 FALSE, /* pc_relative */
580 0, /* bitpos */
581 complain_overflow_signed, /* complain_on_overflow */
582 nds32_elf_sda15_reloc, /* special_function */
583 "R_NDS32_SDA15S0", /* name */
584 FALSE, /* partial_inplace */
585 0x00007fff, /* src_mask */
586 0x00007fff, /* dst_mask */
587 FALSE), /* pcrel_offset */
588
589 /* GNU extension to record C++ vtable hierarchy */
590 HOWTO (R_NDS32_GNU_VTINHERIT, /* type */
591 0, /* rightshift */
592 2, /* size (0 = byte, 1 = short, 2 = long) */
593 0, /* bitsize */
594 FALSE, /* pc_relative */
595 0, /* bitpos */
596 complain_overflow_dont,/* complain_on_overflow */
597 NULL, /* special_function */
598 "R_NDS32_GNU_VTINHERIT", /* name */
599 FALSE, /* partial_inplace */
600 0, /* src_mask */
601 0, /* dst_mask */
602 FALSE), /* pcrel_offset */
603
604 /* GNU extension to record C++ vtable member usage */
605 HOWTO (R_NDS32_GNU_VTENTRY, /* type */
606 0, /* rightshift */
607 2, /* size (0 = byte, 1 = short, 2 = long) */
608 0, /* bitsize */
609 FALSE, /* pc_relative */
610 0, /* bitpos */
611 complain_overflow_dont,/* complain_on_overflow */
612 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
613 "R_NDS32_GNU_VTENTRY", /* name */
614 FALSE, /* partial_inplace */
615 0, /* src_mask */
616 0, /* dst_mask */
617 FALSE), /* pcrel_offset */
618
619 /* A 16 bit absolute relocation. */
620 HOWTO (R_NDS32_16_RELA, /* type */
621 0, /* rightshift */
622 1, /* size (0 = byte, 1 = short, 2 = long) */
623 16, /* bitsize */
624 FALSE, /* pc_relative */
625 0, /* bitpos */
626 complain_overflow_bitfield, /* complain_on_overflow */
627 bfd_elf_generic_reloc, /* special_function */
628 "R_NDS32_16_RELA", /* name */
629 FALSE, /* partial_inplace */
630 0xffff, /* src_mask */
631 0xffff, /* dst_mask */
632 FALSE), /* pcrel_offset */
633
634 /* A 32 bit absolute relocation. */
635 HOWTO (R_NDS32_32_RELA, /* type */
636 0, /* rightshift */
637 2, /* size (0 = byte, 1 = short, 2 = long) */
638 32, /* bitsize */
639 FALSE, /* pc_relative */
640 0, /* bitpos */
641 complain_overflow_bitfield, /* complain_on_overflow */
642 bfd_elf_generic_reloc, /* special_function */
643 "R_NDS32_32_RELA", /* name */
644 FALSE, /* partial_inplace */
645 0xffffffff, /* src_mask */
646 0xffffffff, /* dst_mask */
647 FALSE), /* pcrel_offset */
648
649 /* A 20 bit address. */
650 HOWTO (R_NDS32_20_RELA, /* type */
651 0, /* rightshift */
652 2, /* size (0 = byte, 1 = short, 2 = long) */
653 20, /* bitsize */
654 FALSE, /* pc_relative */
655 0, /* bitpos */
656 complain_overflow_signed, /* complain_on_overflow */
657 bfd_elf_generic_reloc, /* special_function */
658 "R_NDS32_20_RELA", /* name */
659 FALSE, /* partial_inplace */
660 0xfffff, /* src_mask */
661 0xfffff, /* dst_mask */
662 FALSE), /* pcrel_offset */
663
664 HOWTO (R_NDS32_9_PCREL_RELA, /* type */
665 1, /* rightshift */
666 1, /* size (0 = byte, 1 = short, 2 = long) */
667 8, /* bitsize */
668 TRUE, /* pc_relative */
669 0, /* bitpos */
670 complain_overflow_signed, /* complain_on_overflow */
671 bfd_elf_generic_reloc, /* special_function */
672 "R_NDS32_9_PCREL_RELA",/* name */
673 FALSE, /* partial_inplace */
674 0xff, /* src_mask */
675 0xff, /* dst_mask */
676 TRUE), /* pcrel_offset */
677
678 /* A relative 15 bit relocation, right shifted by 1. */
679 HOWTO (R_NDS32_15_PCREL_RELA, /* type */
680 1, /* rightshift */
681 2, /* size (0 = byte, 1 = short, 2 = long) */
682 14, /* bitsize */
683 TRUE, /* pc_relative */
684 0, /* bitpos */
685 complain_overflow_signed, /* complain_on_overflow */
686 bfd_elf_generic_reloc, /* special_function */
687 "R_NDS32_15_PCREL_RELA", /* name */
688 FALSE, /* partial_inplace */
689 0x3fff, /* src_mask */
690 0x3fff, /* dst_mask */
691 TRUE), /* pcrel_offset */
692
693 /* A relative 17 bit relocation, right shifted by 1. */
694 HOWTO (R_NDS32_17_PCREL_RELA, /* type */
695 1, /* rightshift */
696 2, /* size (0 = byte, 1 = short, 2 = long) */
697 16, /* bitsize */
698 TRUE, /* pc_relative */
699 0, /* bitpos */
700 complain_overflow_signed, /* complain_on_overflow */
701 bfd_elf_generic_reloc, /* special_function */
702 "R_NDS32_17_PCREL_RELA", /* name */
703 FALSE, /* partial_inplace */
704 0xffff, /* src_mask */
705 0xffff, /* dst_mask */
706 TRUE), /* pcrel_offset */
707
708 /* A relative 25 bit relocation, right shifted by 2. */
709 HOWTO (R_NDS32_25_PCREL_RELA, /* type */
710 1, /* rightshift */
711 2, /* size (0 = byte, 1 = short, 2 = long) */
712 24, /* bitsize */
713 TRUE, /* pc_relative */
714 0, /* bitpos */
715 complain_overflow_signed, /* complain_on_overflow */
716 bfd_elf_generic_reloc, /* special_function */
717 "R_NDS32_25_PCREL_RELA", /* name */
718 FALSE, /* partial_inplace */
719 0xffffff, /* src_mask */
720 0xffffff, /* dst_mask */
721 TRUE), /* pcrel_offset */
722
723 /* High 20 bits of address when lower 16 is or'd in. */
724 HOWTO (R_NDS32_HI20_RELA, /* type */
725 12, /* rightshift */
726 2, /* size (0 = byte, 1 = short, 2 = long) */
727 20, /* bitsize */
728 FALSE, /* pc_relative */
729 0, /* bitpos */
730 complain_overflow_dont,/* complain_on_overflow */
731 bfd_elf_generic_reloc, /* special_function */
732 "R_NDS32_HI20_RELA", /* name */
733 FALSE, /* partial_inplace */
734 0x000fffff, /* src_mask */
735 0x000fffff, /* dst_mask */
736 FALSE), /* pcrel_offset */
737
738 /* Lower 12 bits of address. */
739 HOWTO (R_NDS32_LO12S3_RELA, /* type */
740 3, /* rightshift */
741 2, /* size (0 = byte, 1 = short, 2 = long) */
742 9, /* bitsize */
743 FALSE, /* pc_relative */
744 0, /* bitpos */
745 complain_overflow_dont,/* complain_on_overflow */
746 bfd_elf_generic_reloc, /* special_function */
747 "R_NDS32_LO12S3_RELA", /* name */
748 FALSE, /* partial_inplace */
749 0x000001ff, /* src_mask */
750 0x000001ff, /* dst_mask */
751 FALSE), /* pcrel_offset */
752
753 /* Lower 12 bits of address. */
754 HOWTO (R_NDS32_LO12S2_RELA, /* type */
755 2, /* rightshift */
756 2, /* size (0 = byte, 1 = short, 2 = long) */
757 10, /* bitsize */
758 FALSE, /* pc_relative */
759 0, /* bitpos */
760 complain_overflow_dont,/* complain_on_overflow */
761 bfd_elf_generic_reloc, /* special_function */
762 "R_NDS32_LO12S2_RELA", /* name */
763 FALSE, /* partial_inplace */
764 0x000003ff, /* src_mask */
765 0x000003ff, /* dst_mask */
766 FALSE), /* pcrel_offset */
767
768 /* Lower 12 bits of address. */
769 HOWTO (R_NDS32_LO12S1_RELA, /* type */
770 1, /* rightshift */
771 2, /* size (0 = byte, 1 = short, 2 = long) */
772 11, /* bitsize */
773 FALSE, /* pc_relative */
774 0, /* bitpos */
775 complain_overflow_dont,/* complain_on_overflow */
776 bfd_elf_generic_reloc, /* special_function */
777 "R_NDS32_LO12S1_RELA", /* name */
778 FALSE, /* partial_inplace */
779 0x000007ff, /* src_mask */
780 0x000007ff, /* dst_mask */
781 FALSE), /* pcrel_offset */
782
783 /* Lower 12 bits of address. */
784 HOWTO (R_NDS32_LO12S0_RELA, /* type */
785 0, /* rightshift */
786 2, /* size (0 = byte, 1 = short, 2 = long) */
787 12, /* bitsize */
788 FALSE, /* pc_relative */
789 0, /* bitpos */
790 complain_overflow_dont,/* complain_on_overflow */
791 bfd_elf_generic_reloc, /* special_function */
792 "R_NDS32_LO12S0_RELA", /* name */
793 FALSE, /* partial_inplace */
794 0x00000fff, /* src_mask */
795 0x00000fff, /* dst_mask */
796 FALSE), /* pcrel_offset */
797
798 /* Small data area 15 bits offset. */
799 HOWTO (R_NDS32_SDA15S3_RELA, /* type */
800 3, /* rightshift */
801 2, /* size (0 = byte, 1 = short, 2 = long) */
802 15, /* bitsize */
803 FALSE, /* pc_relative */
804 0, /* bitpos */
805 complain_overflow_signed, /* complain_on_overflow */
806 bfd_elf_generic_reloc, /* special_function */
807 "R_NDS32_SDA15S3_RELA",/* name */
808 FALSE, /* partial_inplace */
809 0x00007fff, /* src_mask */
810 0x00007fff, /* dst_mask */
811 FALSE), /* pcrel_offset */
812
813 /* Small data area 15 bits offset. */
814 HOWTO (R_NDS32_SDA15S2_RELA, /* type */
815 2, /* rightshift */
816 2, /* size (0 = byte, 1 = short, 2 = long) */
817 15, /* bitsize */
818 FALSE, /* pc_relative */
819 0, /* bitpos */
820 complain_overflow_signed, /* complain_on_overflow */
821 bfd_elf_generic_reloc, /* special_function */
822 "R_NDS32_SDA15S2_RELA",/* name */
823 FALSE, /* partial_inplace */
824 0x00007fff, /* src_mask */
825 0x00007fff, /* dst_mask */
826 FALSE), /* pcrel_offset */
827
828 HOWTO (R_NDS32_SDA15S1_RELA, /* type */
829 1, /* rightshift */
830 2, /* size (0 = byte, 1 = short, 2 = long) */
831 15, /* bitsize */
832 FALSE, /* pc_relative */
833 0, /* bitpos */
834 complain_overflow_signed, /* complain_on_overflow */
835 bfd_elf_generic_reloc, /* special_function */
836 "R_NDS32_SDA15S1_RELA",/* name */
837 FALSE, /* partial_inplace */
838 0x00007fff, /* src_mask */
839 0x00007fff, /* dst_mask */
840 FALSE), /* pcrel_offset */
841
842 HOWTO (R_NDS32_SDA15S0_RELA, /* type */
843 0, /* rightshift */
844 2, /* size (0 = byte, 1 = short, 2 = long) */
845 15, /* bitsize */
846 FALSE, /* pc_relative */
847 0, /* bitpos */
848 complain_overflow_signed, /* complain_on_overflow */
849 bfd_elf_generic_reloc, /* special_function */
850 "R_NDS32_SDA15S0_RELA",/* name */
851 FALSE, /* partial_inplace */
852 0x00007fff, /* src_mask */
853 0x00007fff, /* dst_mask */
854 FALSE), /* pcrel_offset */
855
856 /* GNU extension to record C++ vtable hierarchy */
857 HOWTO (R_NDS32_RELA_GNU_VTINHERIT, /* type */
858 0, /* rightshift */
859 2, /* size (0 = byte, 1 = short, 2 = long) */
860 0, /* bitsize */
861 FALSE, /* pc_relative */
862 0, /* bitpos */
863 complain_overflow_dont,/* complain_on_overflow */
864 NULL, /* special_function */
865 "R_NDS32_RELA_GNU_VTINHERIT", /* name */
866 FALSE, /* partial_inplace */
867 0, /* src_mask */
868 0, /* dst_mask */
869 FALSE), /* pcrel_offset */
870
871 /* GNU extension to record C++ vtable member usage */
872 HOWTO (R_NDS32_RELA_GNU_VTENTRY, /* type */
873 0, /* rightshift */
874 2, /* size (0 = byte, 1 = short, 2 = long) */
875 0, /* bitsize */
876 FALSE, /* pc_relative */
877 0, /* bitpos */
878 complain_overflow_dont,/* complain_on_overflow */
879 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
880 "R_NDS32_RELA_GNU_VTENTRY", /* name */
881 FALSE, /* partial_inplace */
882 0, /* src_mask */
883 0, /* dst_mask */
884 FALSE), /* pcrel_offset */
885
886 /* Like R_NDS32_20, but referring to the GOT table entry for
887 the symbol. */
888 HOWTO (R_NDS32_GOT20, /* type */
889 0, /* rightshift */
890 2, /* size (0 = byte, 1 = short, 2 = long) */
891 20, /* bitsize */
892 FALSE, /* pc_relative */
893 0, /* bitpos */
894 complain_overflow_signed, /* complain_on_overflow */
895 bfd_elf_generic_reloc, /* special_function */
896 "R_NDS32_GOT20", /* name */
897 FALSE, /* partial_inplace */
898 0xfffff, /* src_mask */
899 0xfffff, /* dst_mask */
900 FALSE), /* pcrel_offset */
901
902 /* Like R_NDS32_PCREL, but referring to the procedure linkage table
903 entry for the symbol. */
904 HOWTO (R_NDS32_25_PLTREL, /* type */
905 1, /* rightshift */
906 2, /* size (0 = byte, 1 = short, 2 = long) */
907 24, /* bitsize */
908 TRUE, /* pc_relative */
909 0, /* bitpos */
910 complain_overflow_signed, /* complain_on_overflow */
911 bfd_elf_generic_reloc, /* special_function */
912 "R_NDS32_25_PLTREL", /* name */
913 FALSE, /* partial_inplace */
914 0xffffff, /* src_mask */
915 0xffffff, /* dst_mask */
916 TRUE), /* pcrel_offset */
917
918 /* This is used only by the dynamic linker. The symbol should exist
919 both in the object being run and in some shared library. The
920 dynamic linker copies the data addressed by the symbol from the
921 shared library into the object, because the object being
922 run has to have the data at some particular address. */
923 HOWTO (R_NDS32_COPY, /* type */
924 0, /* rightshift */
925 2, /* size (0 = byte, 1 = short, 2 = long) */
926 32, /* bitsize */
927 FALSE, /* pc_relative */
928 0, /* bitpos */
929 complain_overflow_bitfield, /* complain_on_overflow */
930 bfd_elf_generic_reloc, /* special_function */
931 "R_NDS32_COPY", /* name */
932 FALSE, /* partial_inplace */
933 0xffffffff, /* src_mask */
934 0xffffffff, /* dst_mask */
935 FALSE), /* pcrel_offset */
936
937 /* Like R_NDS32_20, but used when setting global offset table
938 entries. */
939 HOWTO (R_NDS32_GLOB_DAT, /* type */
940 0, /* rightshift */
941 2, /* size (0 = byte, 1 = short, 2 = long) */
942 32, /* bitsize */
943 FALSE, /* pc_relative */
944 0, /* bitpos */
945 complain_overflow_bitfield, /* complain_on_overflow */
946 bfd_elf_generic_reloc, /* special_function */
947 "R_NDS32_GLOB_DAT", /* name */
948 FALSE, /* partial_inplace */
949 0xffffffff, /* src_mask */
950 0xffffffff, /* dst_mask */
951 FALSE), /* pcrel_offset */
952
953 /* Marks a procedure linkage table entry for a symbol. */
954 HOWTO (R_NDS32_JMP_SLOT, /* type */
955 0, /* rightshift */
956 2, /* size (0 = byte, 1 = short, 2 = long) */
957 32, /* bitsize */
958 FALSE, /* pc_relative */
959 0, /* bitpos */
960 complain_overflow_bitfield, /* complain_on_overflow */
961 bfd_elf_generic_reloc, /* special_function */
962 "R_NDS32_JMP_SLOT", /* name */
963 FALSE, /* partial_inplace */
964 0xffffffff, /* src_mask */
965 0xffffffff, /* dst_mask */
966 FALSE), /* pcrel_offset */
967
968 /* Used only by the dynamic linker. When the object is run, this
969 longword is set to the load address of the object, plus the
970 addend. */
971 HOWTO (R_NDS32_RELATIVE, /* type */
972 0, /* rightshift */
973 2, /* size (0 = byte, 1 = short, 2 = long) */
974 32, /* bitsize */
975 FALSE, /* pc_relative */
976 0, /* bitpos */
977 complain_overflow_bitfield, /* complain_on_overflow */
978 bfd_elf_generic_reloc, /* special_function */
979 "R_NDS32_RELATIVE", /* name */
980 FALSE, /* partial_inplace */
981 0xffffffff, /* src_mask */
982 0xffffffff, /* dst_mask */
983 FALSE), /* pcrel_offset */
984
985 HOWTO (R_NDS32_GOTOFF, /* type */
986 0, /* rightshift */
987 2, /* size (0 = byte, 1 = short, 2 = long) */
988 20, /* bitsize */
989 FALSE, /* pc_relative */
990 0, /* bitpos */
991 complain_overflow_signed, /* complain_on_overflow */
992 bfd_elf_generic_reloc, /* special_function */
993 "R_NDS32_GOTOFF", /* name */
994 FALSE, /* partial_inplace */
995 0xfffff, /* src_mask */
996 0xfffff, /* dst_mask */
997 FALSE), /* pcrel_offset */
998
999 /* An PC Relative 20-bit relocation used when setting PIC offset
1000 table register. */
1001 HOWTO (R_NDS32_GOTPC20, /* type */
1002 0, /* rightshift */
1003 2, /* size (0 = byte, 1 = short, 2 = long) */
1004 20, /* bitsize */
1005 TRUE, /* pc_relative */
1006 0, /* bitpos */
1007 complain_overflow_signed, /* complain_on_overflow */
1008 bfd_elf_generic_reloc, /* special_function */
1009 "R_NDS32_GOTPC20", /* name */
1010 FALSE, /* partial_inplace */
1011 0xfffff, /* src_mask */
1012 0xfffff, /* dst_mask */
1013 TRUE), /* pcrel_offset */
1014
1015 /* Like R_NDS32_HI20, but referring to the GOT table entry for
1016 the symbol. */
1017 HOWTO (R_NDS32_GOT_HI20, /* type */
1018 12, /* rightshift */
1019 2, /* size (0 = byte, 1 = short, 2 = long) */
1020 20, /* bitsize */
1021 FALSE, /* pc_relative */
1022 0, /* bitpos */
1023 complain_overflow_dont,/* complain_on_overflow */
1024 bfd_elf_generic_reloc, /* special_function */
1025 "R_NDS32_GOT_HI20", /* name */
1026 FALSE, /* partial_inplace */
1027 0x000fffff, /* src_mask */
1028 0x000fffff, /* dst_mask */
1029 FALSE), /* pcrel_offset */
1030 HOWTO (R_NDS32_GOT_LO12, /* type */
1031 0, /* rightshift */
1032 2, /* size (0 = byte, 1 = short, 2 = long) */
1033 12, /* bitsize */
1034 FALSE, /* pc_relative */
1035 0, /* bitpos */
1036 complain_overflow_dont,/* complain_on_overflow */
1037 bfd_elf_generic_reloc, /* special_function */
1038 "R_NDS32_GOT_LO12", /* name */
1039 FALSE, /* partial_inplace */
1040 0x00000fff, /* src_mask */
1041 0x00000fff, /* dst_mask */
1042 FALSE), /* pcrel_offset */
1043
1044 /* An PC Relative relocation used when setting PIC offset table register.
1045 Like R_NDS32_HI20, but referring to the GOT table entry for
1046 the symbol. */
1047 HOWTO (R_NDS32_GOTPC_HI20, /* type */
1048 12, /* rightshift */
1049 2, /* size (0 = byte, 1 = short, 2 = long) */
1050 20, /* bitsize */
1051 FALSE, /* pc_relative */
1052 0, /* bitpos */
1053 complain_overflow_dont,/* complain_on_overflow */
1054 bfd_elf_generic_reloc, /* special_function */
1055 "R_NDS32_GOTPC_HI20", /* name */
1056 FALSE, /* partial_inplace */
1057 0x000fffff, /* src_mask */
1058 0x000fffff, /* dst_mask */
1059 TRUE), /* pcrel_offset */
1060 HOWTO (R_NDS32_GOTPC_LO12, /* type */
1061 0, /* rightshift */
1062 2, /* size (0 = byte, 1 = short, 2 = long) */
1063 12, /* bitsize */
1064 FALSE, /* pc_relative */
1065 0, /* bitpos */
1066 complain_overflow_dont, /* complain_on_overflow */
1067 bfd_elf_generic_reloc, /* special_function */
1068 "R_NDS32_GOTPC_LO12", /* name */
1069 FALSE, /* partial_inplace */
1070 0x00000fff, /* src_mask */
1071 0x00000fff, /* dst_mask */
1072 TRUE), /* pcrel_offset */
1073
1074 HOWTO (R_NDS32_GOTOFF_HI20, /* type */
1075 12, /* rightshift */
1076 2, /* size (0 = byte, 1 = short, 2 = long) */
1077 20, /* bitsize */
1078 FALSE, /* pc_relative */
1079 0, /* bitpos */
1080 complain_overflow_dont,/* complain_on_overflow */
1081 bfd_elf_generic_reloc, /* special_function */
1082 "R_NDS32_GOTOFF_HI20", /* name */
1083 FALSE, /* partial_inplace */
1084 0x000fffff, /* src_mask */
1085 0x000fffff, /* dst_mask */
1086 FALSE), /* pcrel_offset */
1087 HOWTO (R_NDS32_GOTOFF_LO12, /* type */
1088 0, /* rightshift */
1089 2, /* size (0 = byte, 1 = short, 2 = long) */
1090 12, /* bitsize */
1091 FALSE, /* pc_relative */
1092 0, /* bitpos */
1093 complain_overflow_dont,/* complain_on_overflow */
1094 bfd_elf_generic_reloc, /* special_function */
1095 "R_NDS32_GOTOFF_LO12", /* name */
1096 FALSE, /* partial_inplace */
1097 0x00000fff, /* src_mask */
1098 0x00000fff, /* dst_mask */
1099 FALSE), /* pcrel_offset */
1100
1101 /* Alignment hint for relaxable instruction. This is used with
1102 R_NDS32_LABEL as a pair. Relax this instruction from 4 bytes to 2
1103 in order to make next label aligned on word boundary. */
1104 HOWTO (R_NDS32_INSN16, /* type */
1105 0, /* rightshift */
1106 2, /* size (0 = byte, 1 = short, 2 = long) */
1107 32, /* bitsize */
1108 FALSE, /* pc_relative */
1109 0, /* bitpos */
1110 complain_overflow_dont,/* complain_on_overflow */
1111 nds32_elf_ignore_reloc,/* special_function */
1112 "R_NDS32_INSN16", /* name */
1113 FALSE, /* partial_inplace */
1114 0x00000fff, /* src_mask */
1115 0x00000fff, /* dst_mask */
1116 FALSE), /* pcrel_offset */
1117
1118 /* Alignment hint for label. */
1119 HOWTO (R_NDS32_LABEL, /* type */
1120 0, /* rightshift */
1121 2, /* size (0 = byte, 1 = short, 2 = long) */
1122 32, /* bitsize */
1123 FALSE, /* pc_relative */
1124 0, /* bitpos */
1125 complain_overflow_dont,/* complain_on_overflow */
1126 nds32_elf_ignore_reloc,/* special_function */
1127 "R_NDS32_LABEL", /* name */
1128 FALSE, /* partial_inplace */
1129 0xffffffff, /* src_mask */
1130 0xffffffff, /* dst_mask */
1131 FALSE), /* pcrel_offset */
1132
1133 /* Relax hint for unconditional call sequence */
1134 HOWTO (R_NDS32_LONGCALL1, /* type */
1135 0, /* rightshift */
1136 2, /* size (0 = byte, 1 = short, 2 = long) */
1137 32, /* bitsize */
1138 FALSE, /* pc_relative */
1139 0, /* bitpos */
1140 complain_overflow_dont,/* complain_on_overflow */
1141 nds32_elf_ignore_reloc,/* special_function */
1142 "R_NDS32_LONGCALL1", /* name */
1143 FALSE, /* partial_inplace */
1144 0xffffffff, /* src_mask */
1145 0xffffffff, /* dst_mask */
1146 FALSE), /* pcrel_offset */
1147
1148 /* Relax hint for conditional call sequence. */
1149 HOWTO (R_NDS32_LONGCALL2, /* type */
1150 0, /* rightshift */
1151 2, /* size (0 = byte, 1 = short, 2 = long) */
1152 32, /* bitsize */
1153 FALSE, /* pc_relative */
1154 0, /* bitpos */
1155 complain_overflow_dont,/* complain_on_overflow */
1156 nds32_elf_ignore_reloc,/* special_function */
1157 "R_NDS32_LONGCALL2", /* name */
1158 FALSE, /* partial_inplace */
1159 0xffffffff, /* src_mask */
1160 0xffffffff, /* dst_mask */
1161 FALSE), /* pcrel_offset */
1162
1163 /* Relax hint for conditional call sequence. */
1164 HOWTO (R_NDS32_LONGCALL3, /* type */
1165 0, /* rightshift */
1166 2, /* size (0 = byte, 1 = short, 2 = long) */
1167 32, /* bitsize */
1168 FALSE, /* pc_relative */
1169 0, /* bitpos */
1170 complain_overflow_dont,/* complain_on_overflow */
1171 nds32_elf_ignore_reloc,/* special_function */
1172 "R_NDS32_LONGCALL3", /* name */
1173 FALSE, /* partial_inplace */
1174 0xffffffff, /* src_mask */
1175 0xffffffff, /* dst_mask */
1176 FALSE), /* pcrel_offset */
1177
1178 /* Relax hint for unconditional branch sequence. */
1179 HOWTO (R_NDS32_LONGJUMP1, /* type */
1180 0, /* rightshift */
1181 2, /* size (0 = byte, 1 = short, 2 = long) */
1182 32, /* bitsize */
1183 FALSE, /* pc_relative */
1184 0, /* bitpos */
1185 complain_overflow_dont,/* complain_on_overflow */
1186 nds32_elf_ignore_reloc,/* special_function */
1187 "R_NDS32_LONGJUMP1", /* name */
1188 FALSE, /* partial_inplace */
1189 0xffffffff, /* src_mask */
1190 0xffffffff, /* dst_mask */
1191 FALSE), /* pcrel_offset */
1192
1193 /* Relax hint for conditional branch sequence. */
1194 HOWTO (R_NDS32_LONGJUMP2, /* type */
1195 0, /* rightshift */
1196 2, /* size (0 = byte, 1 = short, 2 = long) */
1197 32, /* bitsize */
1198 FALSE, /* pc_relative */
1199 0, /* bitpos */
1200 complain_overflow_dont,/* complain_on_overflow */
1201 nds32_elf_ignore_reloc,/* special_function */
1202 "R_NDS32_LONGJUMP2", /* name */
1203 FALSE, /* partial_inplace */
1204 0xffffffff, /* src_mask */
1205 0xffffffff, /* dst_mask */
1206 FALSE), /* pcrel_offset */
1207
1208 /* Relax hint for conditional branch sequence. */
1209 HOWTO (R_NDS32_LONGJUMP3, /* type */
1210 0, /* rightshift */
1211 2, /* size (0 = byte, 1 = short, 2 = long) */
1212 32, /* bitsize */
1213 FALSE, /* pc_relative */
1214 0, /* bitpos */
1215 complain_overflow_dont,/* complain_on_overflow */
1216 nds32_elf_ignore_reloc,/* special_function */
1217 "R_NDS32_LONGJUMP3", /* name */
1218 FALSE, /* partial_inplace */
1219 0xffffffff, /* src_mask */
1220 0xffffffff, /* dst_mask */
1221 FALSE), /* pcrel_offset */
1222
1223 /* Relax hint for load/store sequence. */
1224 HOWTO (R_NDS32_LOADSTORE, /* type */
1225 0, /* rightshift */
1226 2, /* size (0 = byte, 1 = short, 2 = long) */
1227 32, /* bitsize */
1228 FALSE, /* pc_relative */
1229 0, /* bitpos */
1230 complain_overflow_dont,/* complain_on_overflow */
1231 nds32_elf_ignore_reloc,/* special_function */
1232 "R_NDS32_LOADSTORE", /* name */
1233 FALSE, /* partial_inplace */
1234 0xffffffff, /* src_mask */
1235 0xffffffff, /* dst_mask */
1236 FALSE), /* pcrel_offset */
1237
1238 /* Relax hint for load/store sequence. */
1239 HOWTO (R_NDS32_9_FIXED_RELA, /* type */
1240 0, /* rightshift */
1241 1, /* size (0 = byte, 1 = short, 2 = long) */
1242 16, /* bitsize */
1243 FALSE, /* pc_relative */
1244 0, /* bitpos */
1245 complain_overflow_dont,/* complain_on_overflow */
1246 nds32_elf_ignore_reloc,/* special_function */
1247 "R_NDS32_9_FIXED_RELA",/* name */
1248 FALSE, /* partial_inplace */
1249 0x000000ff, /* src_mask */
1250 0x000000ff, /* dst_mask */
1251 FALSE), /* pcrel_offset */
1252
1253 /* Relax hint for load/store sequence. */
1254 HOWTO (R_NDS32_15_FIXED_RELA, /* type */
1255 0, /* rightshift */
1256 2, /* size (0 = byte, 1 = short, 2 = long) */
1257 32, /* bitsize */
1258 FALSE, /* pc_relative */
1259 0, /* bitpos */
1260 complain_overflow_dont,/* complain_on_overflow */
1261 nds32_elf_ignore_reloc,/* special_function */
1262 "R_NDS32_15_FIXED_RELA", /* name */
1263 FALSE, /* partial_inplace */
1264 0x00003fff, /* src_mask */
1265 0x00003fff, /* dst_mask */
1266 FALSE), /* pcrel_offset */
1267
1268 /* Relax hint for load/store sequence. */
1269 HOWTO (R_NDS32_17_FIXED_RELA, /* type */
1270 0, /* rightshift */
1271 2, /* size (0 = byte, 1 = short, 2 = long) */
1272 32, /* bitsize */
1273 FALSE, /* pc_relative */
1274 0, /* bitpos */
1275 complain_overflow_dont,/* complain_on_overflow */
1276 nds32_elf_ignore_reloc,/* special_function */
1277 "R_NDS32_17_FIXED_RELA", /* name */
1278 FALSE, /* partial_inplace */
1279 0x0000ffff, /* src_mask */
1280 0x0000ffff, /* dst_mask */
1281 FALSE), /* pcrel_offset */
1282
1283 /* Relax hint for load/store sequence. */
1284 HOWTO (R_NDS32_25_FIXED_RELA, /* type */
1285 0, /* rightshift */
1286 2, /* size (0 = byte, 1 = short, 2 = long) */
1287 32, /* bitsize */
1288 FALSE, /* pc_relative */
1289 0, /* bitpos */
1290 complain_overflow_dont,/* complain_on_overflow */
1291 nds32_elf_ignore_reloc,/* special_function */
1292 "R_NDS32_25_FIXED_RELA", /* name */
1293 FALSE, /* partial_inplace */
1294 0x00ffffff, /* src_mask */
1295 0x00ffffff, /* dst_mask */
1296 FALSE), /* pcrel_offset */
1297
1298 /* High 20 bits of PLT symbol offset relative to PC. */
1299 HOWTO (R_NDS32_PLTREL_HI20, /* type */
1300 12, /* rightshift */
1301 2, /* size (0 = byte, 1 = short, 2 = long) */
1302 20, /* bitsize */
1303 FALSE, /* pc_relative */
1304 0, /* bitpos */
1305 complain_overflow_dont,/* complain_on_overflow */
1306 bfd_elf_generic_reloc, /* special_function */
1307 "R_NDS32_PLTREL_HI20", /* name */
1308 FALSE, /* partial_inplace */
1309 0x000fffff, /* src_mask */
1310 0x000fffff, /* dst_mask */
1311 FALSE), /* pcrel_offset */
1312
1313 /* Low 12 bits of PLT symbol offset relative to PC. */
1314 HOWTO (R_NDS32_PLTREL_LO12, /* type */
1315 0, /* rightshift */
1316 2, /* size (0 = byte, 1 = short, 2 = long) */
1317 12, /* bitsize */
1318 FALSE, /* pc_relative */
1319 0, /* bitpos */
1320 complain_overflow_dont,/* complain_on_overflow */
1321 bfd_elf_generic_reloc, /* special_function */
1322 "R_NDS32_PLTREL_LO12", /* name */
1323 FALSE, /* partial_inplace */
1324 0x00000fff, /* src_mask */
1325 0x00000fff, /* dst_mask */
1326 FALSE), /* pcrel_offset */
1327
1328 /* High 20 bits of PLT symbol offset relative to GOT (GP). */
1329 HOWTO (R_NDS32_PLT_GOTREL_HI20, /* type */
1330 12, /* rightshift */
1331 2, /* size (0 = byte, 1 = short, 2 = long) */
1332 20, /* bitsize */
1333 FALSE, /* pc_relative */
1334 0, /* bitpos */
1335 complain_overflow_dont,/* complain_on_overflow */
1336 bfd_elf_generic_reloc, /* special_function */
1337 "R_NDS32_PLT_GOTREL_HI20", /* name */
1338 FALSE, /* partial_inplace */
1339 0x000fffff, /* src_mask */
1340 0x000fffff, /* dst_mask */
1341 FALSE), /* pcrel_offset */
1342
1343 /* Low 12 bits of PLT symbol offset relative to GOT (GP). */
1344 HOWTO (R_NDS32_PLT_GOTREL_LO12, /* type */
1345 0, /* rightshift */
1346 2, /* size (0 = byte, 1 = short, 2 = long) */
1347 12, /* bitsize */
1348 FALSE, /* pc_relative */
1349 0, /* bitpos */
1350 complain_overflow_dont,/* complain_on_overflow */
1351 bfd_elf_generic_reloc, /* special_function */
1352 "R_NDS32_PLT_GOTREL_LO12", /* name */
1353 FALSE, /* partial_inplace */
1354 0x00000fff, /* src_mask */
1355 0x00000fff, /* dst_mask */
1356 FALSE), /* pcrel_offset */
1357
1358 /* Small data area 12 bits offset. */
1359 HOWTO (R_NDS32_SDA12S2_DP_RELA, /* type */
1360 2, /* rightshift */
1361 2, /* size (0 = byte, 1 = short, 2 = long) */
1362 12, /* bitsize */
1363 FALSE, /* pc_relative */
1364 0, /* bitpos */
1365 complain_overflow_signed, /* complain_on_overflow */
1366 bfd_elf_generic_reloc, /* special_function */
1367 "R_NDS32_SDA12S2_DP_RELA", /* name */
1368 FALSE, /* partial_inplace */
1369 0x00000fff, /* src_mask */
1370 0x00000fff, /* dst_mask */
1371 FALSE), /* pcrel_offset */
1372
1373 /* Small data area 12 bits offset. */
1374 HOWTO (R_NDS32_SDA12S2_SP_RELA, /* type */
1375 2, /* rightshift */
1376 2, /* size (0 = byte, 1 = short, 2 = long) */
1377 12, /* bitsize */
1378 FALSE, /* pc_relative */
1379 0, /* bitpos */
1380 complain_overflow_signed, /* complain_on_overflow */
1381 bfd_elf_generic_reloc, /* special_function */
1382 "R_NDS32_SDA12S2_SP_RELA", /* name */
1383 FALSE, /* partial_inplace */
1384 0x00000fff, /* src_mask */
1385 0x00000fff, /* dst_mask */
1386 FALSE), /* pcrel_offset */
1387 /* Lower 12 bits of address. */
1388
1389 HOWTO (R_NDS32_LO12S2_DP_RELA, /* type */
1390 2, /* rightshift */
1391 2, /* size (0 = byte, 1 = short, 2 = long) */
1392 10, /* bitsize */
1393 FALSE, /* pc_relative */
1394 0, /* bitpos */
1395 complain_overflow_dont,/* complain_on_overflow */
1396 bfd_elf_generic_reloc, /* special_function */
1397 "R_NDS32_LO12S2_DP_RELA", /* name */
1398 FALSE, /* partial_inplace */
1399 0x000003ff, /* src_mask */
1400 0x000003ff, /* dst_mask */
1401 FALSE), /* pcrel_offset */
1402
1403 /* Lower 12 bits of address. */
1404 HOWTO (R_NDS32_LO12S2_SP_RELA,/* type */
1405 2, /* rightshift */
1406 2, /* size (0 = byte, 1 = short, 2 = long) */
1407 10, /* bitsize */
1408 FALSE, /* pc_relative */
1409 0, /* bitpos */
1410 complain_overflow_dont,/* complain_on_overflow */
1411 bfd_elf_generic_reloc, /* special_function */
1412 "R_NDS32_LO12S2_SP_RELA", /* name */
1413 FALSE, /* partial_inplace */
1414 0x000003ff, /* src_mask */
1415 0x000003ff, /* dst_mask */
1416 FALSE), /* pcrel_offset */
1417 /* Lower 12 bits of address. Special identity for or case. */
1418 HOWTO (R_NDS32_LO12S0_ORI_RELA, /* type */
1419 0, /* rightshift */
1420 2, /* size (0 = byte, 1 = short, 2 = long) */
1421 12, /* bitsize */
1422 FALSE, /* pc_relative */
1423 0, /* bitpos */
1424 complain_overflow_dont,/* complain_on_overflow */
1425 bfd_elf_generic_reloc, /* special_function */
1426 "R_NDS32_LO12S0_ORI_RELA", /* name */
1427 FALSE, /* partial_inplace */
1428 0x00000fff, /* src_mask */
1429 0x00000fff, /* dst_mask */
1430 FALSE), /* pcrel_offset */
1431 /* Small data area 19 bits offset. */
1432 HOWTO (R_NDS32_SDA16S3_RELA, /* type */
1433 3, /* rightshift */
1434 2, /* size (0 = byte, 1 = short, 2 = long) */
1435 16, /* bitsize */
1436 FALSE, /* pc_relative */
1437 0, /* bitpos */
1438 complain_overflow_signed, /* complain_on_overflow */
1439 bfd_elf_generic_reloc, /* special_function */
1440 "R_NDS32_SDA16S3_RELA",/* name */
1441 FALSE, /* partial_inplace */
1442 0x0000ffff, /* src_mask */
1443 0x0000ffff, /* dst_mask */
1444 FALSE), /* pcrel_offset */
1445
1446 /* Small data area 15 bits offset. */
1447 HOWTO (R_NDS32_SDA17S2_RELA, /* type */
1448 2, /* rightshift */
1449 2, /* size (0 = byte, 1 = short, 2 = long) */
1450 17, /* bitsize */
1451 FALSE, /* pc_relative */
1452 0, /* bitpos */
1453 complain_overflow_signed, /* complain_on_overflow */
1454 bfd_elf_generic_reloc, /* special_function */
1455 "R_NDS32_SDA17S2_RELA",/* name */
1456 FALSE, /* partial_inplace */
1457 0x0001ffff, /* src_mask */
1458 0x0001ffff, /* dst_mask */
1459 FALSE), /* pcrel_offset */
1460
1461 HOWTO (R_NDS32_SDA18S1_RELA, /* type */
1462 1, /* rightshift */
1463 2, /* size (0 = byte, 1 = short, 2 = long) */
1464 18, /* bitsize */
1465 FALSE, /* pc_relative */
1466 0, /* bitpos */
1467 complain_overflow_signed, /* complain_on_overflow */
1468 bfd_elf_generic_reloc, /* special_function */
1469 "R_NDS32_SDA18S1_RELA",/* name */
1470 FALSE, /* partial_inplace */
1471 0x0003ffff, /* src_mask */
1472 0x0003ffff, /* dst_mask */
1473 FALSE), /* pcrel_offset */
1474
1475 HOWTO (R_NDS32_SDA19S0_RELA, /* type */
1476 0, /* rightshift */
1477 2, /* size (0 = byte, 1 = short, 2 = long) */
1478 19, /* bitsize */
1479 FALSE, /* pc_relative */
1480 0, /* bitpos */
1481 complain_overflow_signed, /* complain_on_overflow */
1482 bfd_elf_generic_reloc, /* special_function */
1483 "R_NDS32_SDA19S0_RELA",/* name */
1484 FALSE, /* partial_inplace */
1485 0x0007ffff, /* src_mask */
1486 0x0007ffff, /* dst_mask */
1487 FALSE), /* pcrel_offset */
1488 HOWTO (R_NDS32_DWARF2_OP1_RELA, /* type */
1489 0, /* rightshift */
1490 0, /* size (0 = byte, 1 = short, 2 = long) */
1491 8, /* bitsize */
1492 FALSE, /* pc_relative */
1493 0, /* bitpos */
1494 complain_overflow_dont,/* complain_on_overflow */
1495 nds32_elf_ignore_reloc,/* special_function */
1496 "R_NDS32_DWARF2_OP1_RELA", /* name */
1497 FALSE, /* partial_inplace */
1498 0xff, /* src_mask */
1499 0xff, /* dst_mask */
1500 FALSE), /* pcrel_offset */
1501 HOWTO (R_NDS32_DWARF2_OP2_RELA, /* type */
1502 0, /* rightshift */
1503 1, /* size (0 = byte, 1 = short, 2 = long) */
1504 16, /* bitsize */
1505 FALSE, /* pc_relative */
1506 0, /* bitpos */
1507 complain_overflow_dont,/* complain_on_overflow */
1508 nds32_elf_ignore_reloc,/* special_function */
1509 "R_NDS32_DWARF2_OP2_RELA", /* name */
1510 FALSE, /* partial_inplace */
1511 0xffff, /* src_mask */
1512 0xffff, /* dst_mask */
1513 FALSE), /* pcrel_offset */
1514 HOWTO (R_NDS32_DWARF2_LEB_RELA, /* type */
1515 0, /* rightshift */
1516 2, /* size (0 = byte, 1 = short, 2 = long) */
1517 32, /* bitsize */
1518 FALSE, /* pc_relative */
1519 0, /* bitpos */
1520 complain_overflow_dont,/* complain_on_overflow */
1521 nds32_elf_ignore_reloc,/* special_function */
1522 "R_NDS32_DWARF2_LEB_RELA", /* name */
1523 FALSE, /* partial_inplace */
1524 0xffffffff, /* src_mask */
1525 0xffffffff, /* dst_mask */
1526 FALSE), /* pcrel_offset */
1527 HOWTO (R_NDS32_UPDATE_TA_RELA,/* type */
1528 0, /* rightshift */
1529 1, /* size (0 = byte, 1 = short, 2 = long) */
1530 16, /* bitsize */
1531 FALSE, /* pc_relative */
1532 0, /* bitpos */
1533 complain_overflow_dont,/* complain_on_overflow */
1534 nds32_elf_ignore_reloc,/* special_function */
1535 "R_NDS32_UPDATE_TA_RELA", /* name */
1536 FALSE, /* partial_inplace */
1537 0xffff, /* src_mask */
1538 0xffff, /* dst_mask */
1539 FALSE), /* pcrel_offset */
1540 /* Like R_NDS32_PCREL, but referring to the procedure linkage table
1541 entry for the symbol. */
1542 HOWTO (R_NDS32_9_PLTREL, /* type */
1543 1, /* rightshift */
1544 1, /* size (0 = byte, 1 = short, 2 = long) */
1545 8, /* bitsize */
1546 TRUE, /* pc_relative */
1547 0, /* bitpos */
1548 complain_overflow_signed, /* complain_on_overflow */
1549 bfd_elf_generic_reloc, /* special_function */
1550 "R_NDS32_9_PLTREL", /* name */
1551 FALSE, /* partial_inplace */
1552 0xff, /* src_mask */
1553 0xff, /* dst_mask */
1554 TRUE), /* pcrel_offset */
1555 /* Low 20 bits of PLT symbol offset relative to GOT (GP). */
1556 HOWTO (R_NDS32_PLT_GOTREL_LO20, /* type */
1557 0, /* rightshift */
1558 2, /* size (0 = byte, 1 = short, 2 = long) */
1559 20, /* bitsize */
1560 FALSE, /* pc_relative */
1561 0, /* bitpos */
1562 complain_overflow_dont,/* complain_on_overflow */
1563 bfd_elf_generic_reloc, /* special_function */
1564 "R_NDS32_PLT_GOTREL_LO20", /* name */
1565 FALSE, /* partial_inplace */
1566 0x000fffff, /* src_mask */
1567 0x000fffff, /* dst_mask */
1568 FALSE), /* pcrel_offset */
1569 /* low 15 bits of PLT symbol offset relative to GOT (GP) */
1570 HOWTO (R_NDS32_PLT_GOTREL_LO15, /* type */
1571 0, /* rightshift */
1572 2, /* size (0 = byte, 1 = short, 2 = long) */
1573 15, /* bitsize */
1574 FALSE, /* pc_relative */
1575 0, /* bitpos */
1576 complain_overflow_dont,/* complain_on_overflow */
1577 bfd_elf_generic_reloc, /* special_function */
1578 "R_NDS32_PLT_GOTREL_LO15", /* name */
1579 FALSE, /* partial_inplace */
1580 0x00007fff, /* src_mask */
1581 0x00007fff, /* dst_mask */
1582 FALSE), /* pcrel_offset */
1583 /* Low 19 bits of PLT symbol offset relative to GOT (GP). */
1584 HOWTO (R_NDS32_PLT_GOTREL_LO19, /* type */
1585 0, /* rightshift */
1586 2, /* size (0 = byte, 1 = short, 2 = long) */
1587 19, /* bitsize */
1588 FALSE, /* pc_relative */
1589 0, /* bitpos */
1590 complain_overflow_dont,/* complain_on_overflow */
1591 bfd_elf_generic_reloc, /* special_function */
1592 "R_NDS32_PLT_GOTREL_LO19", /* name */
1593 FALSE, /* partial_inplace */
1594 0x0007ffff, /* src_mask */
1595 0x0007ffff, /* dst_mask */
1596 FALSE), /* pcrel_offset */
1597 HOWTO (R_NDS32_GOT_LO15, /* type */
1598 0, /* rightshift */
1599 2, /* size (0 = byte, 1 = short, 2 = long) */
1600 15, /* bitsize */
1601 FALSE, /* pc_relative */
1602 0, /* bitpos */
1603 complain_overflow_dont,/* complain_on_overflow */
1604 bfd_elf_generic_reloc, /* special_function */
1605 "R_NDS32_GOT_LO15", /* name */
1606 FALSE, /* partial_inplace */
1607 0x00007fff, /* src_mask */
1608 0x00007fff, /* dst_mask */
1609 FALSE), /* pcrel_offset */
1610 HOWTO (R_NDS32_GOT_LO19, /* type */
1611 0, /* rightshift */
1612 2, /* size (0 = byte, 1 = short, 2 = long) */
1613 19, /* bitsize */
1614 FALSE, /* pc_relative */
1615 0, /* bitpos */
1616 complain_overflow_dont,/* complain_on_overflow */
1617 bfd_elf_generic_reloc, /* special_function */
1618 "R_NDS32_GOT_LO19", /* name */
1619 FALSE, /* partial_inplace */
1620 0x0007ffff, /* src_mask */
1621 0x0007ffff, /* dst_mask */
1622 FALSE), /* pcrel_offset */
1623 HOWTO (R_NDS32_GOTOFF_LO15, /* type */
1624 0, /* rightshift */
1625 2, /* size (0 = byte, 1 = short, 2 = long) */
1626 15, /* bitsize */
1627 FALSE, /* pc_relative */
1628 0, /* bitpos */
1629 complain_overflow_dont,/* complain_on_overflow */
1630 bfd_elf_generic_reloc, /* special_function */
1631 "R_NDS32_GOTOFF_LO15", /* name */
1632 FALSE, /* partial_inplace */
1633 0x00007fff, /* src_mask */
1634 0x00007fff, /* dst_mask */
1635 FALSE), /* pcrel_offset */
1636 HOWTO (R_NDS32_GOTOFF_LO19, /* type */
1637 0, /* rightshift */
1638 2, /* size (0 = byte, 1 = short, 2 = long) */
1639 19, /* bitsize */
1640 FALSE, /* pc_relative */
1641 0, /* bitpos */
1642 complain_overflow_dont,/* complain_on_overflow */
1643 bfd_elf_generic_reloc, /* special_function */
1644 "R_NDS32_GOTOFF_LO19", /* name */
1645 FALSE, /* partial_inplace */
1646 0x0007ffff, /* src_mask */
1647 0x0007ffff, /* dst_mask */
1648 FALSE), /* pcrel_offset */
1649 /* GOT 15 bits offset. */
1650 HOWTO (R_NDS32_GOT15S2_RELA, /* type */
1651 2, /* rightshift */
1652 2, /* size (0 = byte, 1 = short, 2 = long) */
1653 15, /* bitsize */
1654 FALSE, /* pc_relative */
1655 0, /* bitpos */
1656 complain_overflow_signed, /* complain_on_overflow */
1657 bfd_elf_generic_reloc, /* special_function */
1658 "R_NDS32_GOT15S2_RELA",/* name */
1659 FALSE, /* partial_inplace */
1660 0x00007fff, /* src_mask */
1661 0x00007fff, /* dst_mask */
1662 FALSE), /* pcrel_offset */
1663 /* GOT 17 bits offset. */
1664 HOWTO (R_NDS32_GOT17S2_RELA, /* type */
1665 2, /* rightshift */
1666 2, /* size (0 = byte, 1 = short, 2 = long) */
1667 17, /* bitsize */
1668 FALSE, /* pc_relative */
1669 0, /* bitpos */
1670 complain_overflow_signed, /* complain_on_overflow */
1671 bfd_elf_generic_reloc, /* special_function */
1672 "R_NDS32_GOT17S2_RELA",/* name */
1673 FALSE, /* partial_inplace */
1674 0x0001ffff, /* src_mask */
1675 0x0001ffff, /* dst_mask */
1676 FALSE), /* pcrel_offset */
1677 /* A 5 bit address. */
1678 HOWTO (R_NDS32_5_RELA, /* type */
1679 0, /* rightshift */
1680 1, /* size (0 = byte, 1 = short, 2 = long) */
1681 5, /* bitsize */
1682 FALSE, /* pc_relative */
1683 0, /* bitpos */
1684 complain_overflow_signed, /* complain_on_overflow */
1685 bfd_elf_generic_reloc, /* special_function */
1686 "R_NDS32_5_RELA", /* name */
1687 FALSE, /* partial_inplace */
1688 0x1f, /* src_mask */
1689 0x1f, /* dst_mask */
1690 FALSE), /* pcrel_offset */
1691 HOWTO (R_NDS32_10_UPCREL_RELA,/* type */
1692 1, /* rightshift */
1693 1, /* size (0 = byte, 1 = short, 2 = long) */
1694 9, /* bitsize */
1695 TRUE, /* pc_relative */
1696 0, /* bitpos */
1697 complain_overflow_unsigned, /* complain_on_overflow */
1698 bfd_elf_generic_reloc, /* special_function */
1699 "R_NDS32_10_UPCREL_RELA", /* name */
1700 FALSE, /* partial_inplace */
1701 0x1ff, /* src_mask */
1702 0x1ff, /* dst_mask */
1703 TRUE), /* pcrel_offset */
1704 HOWTO (R_NDS32_SDA_FP7U2_RELA,/* type */
1705 2, /* rightshift */
1706 1, /* size (0 = byte, 1 = short, 2 = long) */
1707 7, /* bitsize */
1708 FALSE, /* pc_relative */
1709 0, /* bitpos */
1710 complain_overflow_unsigned, /* complain_on_overflow */
1711 bfd_elf_generic_reloc, /* special_function */
1712 "R_NDS32_SDA_FP7U2_RELA", /* name */
1713 FALSE, /* partial_inplace */
1714 0x0000007f, /* src_mask */
1715 0x0000007f, /* dst_mask */
1716 FALSE), /* pcrel_offset */
1717 HOWTO (R_NDS32_WORD_9_PCREL_RELA, /* type */
1718 1, /* rightshift */
1719 2, /* size (0 = byte, 1 = short, 2 = long) */
1720 8, /* bitsize */
1721 TRUE, /* pc_relative */
1722 0, /* bitpos */
1723 complain_overflow_signed, /* complain_on_overflow */
1724 bfd_elf_generic_reloc, /* special_function */
1725 "R_NDS32_WORD_9_PCREL_RELA", /* name */
1726 FALSE, /* partial_inplace */
1727 0xff, /* src_mask */
1728 0xff, /* dst_mask */
1729 TRUE), /* pcrel_offset */
1730 HOWTO (R_NDS32_25_ABS_RELA, /* type */
1731 1, /* rightshift */
1732 2, /* size (0 = byte, 1 = short, 2 = long) */
1733 24, /* bitsize */
1734 FALSE, /* pc_relative */
1735 0, /* bitpos */
1736 complain_overflow_dont,/* complain_on_overflow */
1737 bfd_elf_generic_reloc, /* special_function */
1738 "R_NDS32_25_ABS_RELA", /* name */
1739 FALSE, /* partial_inplace */
1740 0xffffff, /* src_mask */
1741 0xffffff, /* dst_mask */
1742 FALSE), /* pcrel_offset */
1743
1744 /* A relative 17 bit relocation for ifc, right shifted by 1. */
1745 HOWTO (R_NDS32_17IFC_PCREL_RELA, /* type */
1746 1, /* rightshift */
1747 2, /* size (0 = byte, 1 = short, 2 = long) */
1748 16, /* bitsize */
1749 TRUE, /* pc_relative */
1750 0, /* bitpos */
1751 complain_overflow_signed, /* complain_on_overflow */
1752 bfd_elf_generic_reloc, /* special_function */
1753 "R_NDS32_17IFC_PCREL_RELA", /* name */
1754 FALSE, /* partial_inplace */
1755 0xffff, /* src_mask */
1756 0xffff, /* dst_mask */
1757 TRUE), /* pcrel_offset */
1758
1759 /* A relative unsigned 10 bit relocation for ifc, right shifted by 1. */
1760 HOWTO (R_NDS32_10IFCU_PCREL_RELA, /* type */
1761 1, /* rightshift */
1762 1, /* size (0 = byte, 1 = short, 2 = long) */
1763 9, /* bitsize */
1764 TRUE, /* pc_relative */
1765 0, /* bitpos */
1766 complain_overflow_unsigned, /* complain_on_overflow */
1767 bfd_elf_generic_reloc, /* special_function */
1768 "R_NDS32_10IFCU_PCREL_RELA", /* name */
1769 FALSE, /* partial_inplace */
1770 0x1ff, /* src_mask */
1771 0x1ff, /* dst_mask */
1772 TRUE), /* pcrel_offset */
1773
1774 /* Like R_NDS32_HI20, but referring to the TLS entry for the symbol. */
1775 HOWTO (R_NDS32_TLS_LE_HI20, /* type */
1776 12, /* rightshift */
1777 2, /* size (0 = byte, 1 = short, 2 = long) */
1778 20, /* bitsize */
1779 FALSE, /* pc_relative */
1780 0, /* bitpos */
1781 complain_overflow_dont, /* complain_on_overflow */
1782 bfd_elf_generic_reloc, /* special_function */
1783 "R_NDS32_TLS_LE_HI20", /* name */
1784 FALSE, /* partial_inplace */
1785 0x000fffff, /* src_mask */
1786 0x000fffff, /* dst_mask */
1787 FALSE), /* pcrel_offset */
1788 HOWTO (R_NDS32_TLS_LE_LO12, /* type */
1789 0, /* rightshift */
1790 2, /* size (0 = byte, 1 = short, 2 = long) */
1791 12, /* bitsize */
1792 FALSE, /* pc_relative */
1793 0, /* bitpos */
1794 complain_overflow_dont, /* complain_on_overflow */
1795 bfd_elf_generic_reloc, /* special_function */
1796 "R_NDS32_TLS_LE_LO12", /* name */
1797 FALSE, /* partial_inplace */
1798 0x00000fff, /* src_mask */
1799 0x00000fff, /* dst_mask */
1800 FALSE), /* pcrel_offset */
1801
1802 /* Like R_NDS32_HI20, but referring to the TLS entry for the symbol. */
1803 HOWTO (R_NDS32_TLS_IE_HI20, /* type */
1804 12, /* rightshift */
1805 2, /* size (0 = byte, 1 = short, 2 = long) */
1806 20, /* bitsize */
1807 FALSE, /* pc_relative */
1808 0, /* bitpos */
1809 complain_overflow_dont, /* complain_on_overflow */
1810 bfd_elf_generic_reloc, /* special_function */
1811 "R_NDS32_TLS_IE_HI20", /* name */
1812 FALSE, /* partial_inplace */
1813 0x000fffff, /* src_mask */
1814 0x000fffff, /* dst_mask */
1815 FALSE), /* pcrel_offset */
1816 HOWTO (R_NDS32_TLS_IE_LO12S2, /* type */
1817 2, /* rightshift */
1818 2, /* size (0 = byte, 1 = short, 2 = long) */
1819 10, /* bitsize */
1820 FALSE, /* pc_relative */
1821 0, /* bitpos */
1822 complain_overflow_dont, /* complain_on_overflow */
1823 bfd_elf_generic_reloc, /* special_function */
1824 "R_NDS32_TLS_IE_LO12S2", /* name */
1825 FALSE, /* partial_inplace */
1826 0x000003ff, /* src_mask */
1827 0x000003ff, /* dst_mask */
1828 FALSE), /* pcrel_offset */
1829 /* Mark a TLS IE entry in GOT. */
1830 HOWTO (R_NDS32_TLS_TPOFF, /* type */
1831 0, /* rightshift */
1832 2, /* size (0 = byte, 1 = short, 2 = long) */
1833 32, /* bitsize */
1834 FALSE, /* pc_relative */
1835 0, /* bitpos */
1836 complain_overflow_bitfield, /* complain_on_overflow */
1837 bfd_elf_generic_reloc, /* special_function */
1838 "R_NDS32_TLS_TPOFF", /* name */
1839 FALSE, /* partial_inplace */
1840 0xffffffff, /* src_mask */
1841 0xffffffff, /* dst_mask */
1842 FALSE), /* pcrel_offset */
1843 /* A 20 bit address. */
1844 HOWTO (R_NDS32_TLS_LE_20, /* type */
1845 0, /* rightshift */
1846 2, /* size (0 = byte, 1 = short, 2 = long) */
1847 20, /* bitsize */
1848 FALSE, /* pc_relative */
1849 0, /* bitpos */
1850 complain_overflow_signed, /* complain_on_overflow */
1851 bfd_elf_generic_reloc, /* special_function */
1852 "R_NDS32_TLS_LE_20", /* name */
1853 FALSE, /* partial_inplace */
1854 0xfffff, /* src_mask */
1855 0xfffff, /* dst_mask */
1856 FALSE), /* pcrel_offset */
1857 HOWTO (R_NDS32_TLS_LE_15S0, /* type */
1858 0, /* rightshift */
1859 2, /* size (0 = byte, 1 = short, 2 = long) */
1860 15, /* bitsize */
1861 FALSE, /* pc_relative */
1862 0, /* bitpos */
1863 complain_overflow_signed, /* complain_on_overflow */
1864 bfd_elf_generic_reloc, /* special_function */
1865 "R_NDS32_TLS_LE_15S0", /* name */
1866 FALSE, /* partial_inplace */
1867 0x7fff, /* src_mask */
1868 0x7fff, /* dst_mask */
1869 FALSE), /* pcrel_offset */
1870 HOWTO (R_NDS32_TLS_LE_15S1, /* type */
1871 1, /* rightshift */
1872 2, /* size (0 = byte, 1 = short, 2 = long) */
1873 15, /* bitsize */
1874 FALSE, /* pc_relative */
1875 0, /* bitpos */
1876 complain_overflow_signed, /* complain_on_overflow */
1877 bfd_elf_generic_reloc, /* special_function */
1878 "R_NDS32_TLS_LE_15S1", /* name */
1879 FALSE, /* partial_inplace */
1880 0x7fff, /* src_mask */
1881 0x7fff, /* dst_mask */
1882 FALSE), /* pcrel_offset */
1883 HOWTO (R_NDS32_TLS_LE_15S2, /* type */
1884 2, /* rightshift */
1885 2, /* size (0 = byte, 1 = short, 2 = long) */
1886 15, /* bitsize */
1887 FALSE, /* pc_relative */
1888 0, /* bitpos */
1889 complain_overflow_signed, /* complain_on_overflow */
1890 bfd_elf_generic_reloc, /* special_function */
1891 "R_NDS32_TLS_LE_15S2", /* name */
1892 FALSE, /* partial_inplace */
1893 0x7fff, /* src_mask */
1894 0x7fff, /* dst_mask */
1895 FALSE), /* pcrel_offset */
1896
1897 /* Relax hint for unconditional call sequence */
1898 HOWTO (R_NDS32_LONGCALL4, /* type */
1899 0, /* rightshift */
1900 2, /* size (0 = byte, 1 = short, 2 = long) */
1901 32, /* bitsize */
1902 FALSE, /* pc_relative */
1903 0, /* bitpos */
1904 complain_overflow_dont, /* complain_on_overflow */
1905 nds32_elf_ignore_reloc, /* special_function */
1906 "R_NDS32_LONGCALL4", /* name */
1907 FALSE, /* partial_inplace */
1908 0xffffffff, /* src_mask */
1909 0xffffffff, /* dst_mask */
1910 FALSE), /* pcrel_offset */
1911
1912 /* Relax hint for conditional call sequence. */
1913 HOWTO (R_NDS32_LONGCALL5, /* type */
1914 0, /* rightshift */
1915 2, /* size (0 = byte, 1 = short, 2 = long) */
1916 32, /* bitsize */
1917 FALSE, /* pc_relative */
1918 0, /* bitpos */
1919 complain_overflow_dont, /* complain_on_overflow */
1920 nds32_elf_ignore_reloc, /* special_function */
1921 "R_NDS32_LONGCALL5", /* name */
1922 FALSE, /* partial_inplace */
1923 0xffffffff, /* src_mask */
1924 0xffffffff, /* dst_mask */
1925 FALSE), /* pcrel_offset */
1926
1927 /* Relax hint for conditional call sequence. */
1928 HOWTO (R_NDS32_LONGCALL6, /* type */
1929 0, /* rightshift */
1930 2, /* size (0 = byte, 1 = short, 2 = long) */
1931 32, /* bitsize */
1932 FALSE, /* pc_relative */
1933 0, /* bitpos */
1934 complain_overflow_dont, /* complain_on_overflow */
1935 nds32_elf_ignore_reloc, /* special_function */
1936 "R_NDS32_LONGCALL6", /* name */
1937 FALSE, /* partial_inplace */
1938 0xffffffff, /* src_mask */
1939 0xffffffff, /* dst_mask */
1940 FALSE), /* pcrel_offset */
1941
1942 /* Relax hint for unconditional branch sequence. */
1943 HOWTO (R_NDS32_LONGJUMP4, /* type */
1944 0, /* rightshift */
1945 2, /* size (0 = byte, 1 = short, 2 = long) */
1946 32, /* bitsize */
1947 FALSE, /* pc_relative */
1948 0, /* bitpos */
1949 complain_overflow_dont, /* complain_on_overflow */
1950 nds32_elf_ignore_reloc, /* special_function */
1951 "R_NDS32_LONGJUMP4", /* name */
1952 FALSE, /* partial_inplace */
1953 0xffffffff, /* src_mask */
1954 0xffffffff, /* dst_mask */
1955 FALSE), /* pcrel_offset */
1956
1957 /* Relax hint for conditional branch sequence. */
1958 HOWTO (R_NDS32_LONGJUMP5, /* type */
1959 0, /* rightshift */
1960 2, /* size (0 = byte, 1 = short, 2 = long) */
1961 32, /* bitsize */
1962 FALSE, /* pc_relative */
1963 0, /* bitpos */
1964 complain_overflow_dont, /* complain_on_overflow */
1965 nds32_elf_ignore_reloc, /* special_function */
1966 "R_NDS32_LONGJUMP5", /* name */
1967 FALSE, /* partial_inplace */
1968 0xffffffff, /* src_mask */
1969 0xffffffff, /* dst_mask */
1970 FALSE), /* pcrel_offset */
1971
1972 /* Relax hint for conditional branch sequence. */
1973 HOWTO (R_NDS32_LONGJUMP6, /* type */
1974 0, /* rightshift */
1975 2, /* size (0 = byte, 1 = short, 2 = long) */
1976 32, /* bitsize */
1977 FALSE, /* pc_relative */
1978 0, /* bitpos */
1979 complain_overflow_dont, /* complain_on_overflow */
1980 nds32_elf_ignore_reloc, /* special_function */
1981 "R_NDS32_LONGJUMP6", /* name */
1982 FALSE, /* partial_inplace */
1983 0xffffffff, /* src_mask */
1984 0xffffffff, /* dst_mask */
1985 FALSE), /* pcrel_offset */
1986
1987 /* Relax hint for conditional branch sequence. */
1988 HOWTO (R_NDS32_LONGJUMP7, /* type */
1989 0, /* rightshift */
1990 2, /* size (0 = byte, 1 = short, 2 = long) */
1991 32, /* bitsize */
1992 FALSE, /* pc_relative */
1993 0, /* bitpos */
1994 complain_overflow_dont, /* complain_on_overflow */
1995 nds32_elf_ignore_reloc, /* special_function */
1996 "R_NDS32_LONGJUMP7", /* name */
1997 FALSE, /* partial_inplace */
1998 0xffffffff, /* src_mask */
1999 0xffffffff, /* dst_mask */
2000 FALSE), /* pcrel_offset */
2001 };
2002
2003 /* Relocations used for relaxation. */
2004 static reloc_howto_type nds32_elf_relax_howto_table[] =
2005 {
2006 HOWTO (R_NDS32_RELAX_ENTRY, /* type */
2007 0, /* rightshift */
2008 2, /* size (0 = byte, 1 = short, 2 = long) */
2009 32, /* bitsize */
2010 FALSE, /* pc_relative */
2011 0, /* bitpos */
2012 complain_overflow_dont,/* complain_on_overflow */
2013 nds32_elf_ignore_reloc,/* special_function */
2014 "R_NDS32_RELAX_ENTRY", /* name */
2015 FALSE, /* partial_inplace */
2016 0xffffffff, /* src_mask */
2017 0xffffffff, /* dst_mask */
2018 FALSE), /* pcrel_offset */
2019 HOWTO (R_NDS32_GOT_SUFF, /* type */
2020 0, /* rightshift */
2021 2, /* size (0 = byte, 1 = short, 2 = long) */
2022 32, /* bitsize */
2023 FALSE, /* pc_relative */
2024 0, /* bitpos */
2025 complain_overflow_dont,/* complain_on_overflow */
2026 nds32_elf_ignore_reloc,/* special_function */
2027 "R_NDS32_GOT_SUFF", /* name */
2028 FALSE, /* partial_inplace */
2029 0xffffffff, /* src_mask */
2030 0xffffffff, /* dst_mask */
2031 FALSE), /* pcrel_offset */
2032 HOWTO (R_NDS32_GOTOFF_SUFF, /* type */
2033 0, /* rightshift */
2034 2, /* size (0 = byte, 1 = short, 2 = long) */
2035 32, /* bitsize */
2036 FALSE, /* pc_relative */
2037 0, /* bitpos */
2038 complain_overflow_bitfield, /* complain_on_overflow */
2039 nds32_elf_ignore_reloc,/* special_function */
2040 "R_NDS32_GOTOFF_SUFF", /* name */
2041 FALSE, /* partial_inplace */
2042 0xffffffff, /* src_mask */
2043 0xffffffff, /* dst_mask */
2044 FALSE), /* pcrel_offset */
2045 HOWTO (R_NDS32_PLT_GOT_SUFF, /* type */
2046 0, /* rightshift */
2047 2, /* size (0 = byte, 1 = short, 2 = long) */
2048 32, /* bitsize */
2049 FALSE, /* pc_relative */
2050 0, /* bitpos */
2051 complain_overflow_dont,/* complain_on_overflow */
2052 nds32_elf_ignore_reloc,/* special_function */
2053 "R_NDS32_PLT_GOT_SUFF",/* name */
2054 FALSE, /* partial_inplace */
2055 0xffffffff, /* src_mask */
2056 0xffffffff, /* dst_mask */
2057 FALSE), /* pcrel_offset */
2058 HOWTO (R_NDS32_MULCALL_SUFF, /* type */
2059 0, /* rightshift */
2060 2, /* size (0 = byte, 1 = short, 2 = long) */
2061 32, /* bitsize */
2062 FALSE, /* pc_relative */
2063 0, /* bitpos */
2064 complain_overflow_dont,/* complain_on_overflow */
2065 nds32_elf_ignore_reloc,/* special_function */
2066 "R_NDS32_MULCALL_SUFF",/* name */
2067 FALSE, /* partial_inplace */
2068 0xffffffff, /* src_mask */
2069 0xffffffff, /* dst_mask */
2070 FALSE), /* pcrel_offset */
2071 HOWTO (R_NDS32_PTR, /* type */
2072 0, /* rightshift */
2073 2, /* size (0 = byte, 1 = short, 2 = long) */
2074 32, /* bitsize */
2075 FALSE, /* pc_relative */
2076 0, /* bitpos */
2077 complain_overflow_dont,/* complain_on_overflow */
2078 nds32_elf_ignore_reloc,/* special_function */
2079 "R_NDS32_PTR", /* name */
2080 FALSE, /* partial_inplace */
2081 0xffffffff, /* src_mask */
2082 0xffffffff, /* dst_mask */
2083 FALSE), /* pcrel_offset */
2084 HOWTO (R_NDS32_PTR_COUNT, /* type */
2085 0, /* rightshift */
2086 2, /* size (0 = byte, 1 = short, 2 = long) */
2087 32, /* bitsize */
2088 FALSE, /* pc_relative */
2089 0, /* bitpos */
2090 complain_overflow_dont,/* complain_on_overflow */
2091 nds32_elf_ignore_reloc,/* special_function */
2092 "R_NDS32_PTR_COUNT", /* name */
2093 FALSE, /* partial_inplace */
2094 0xffffffff, /* src_mask */
2095 0xffffffff, /* dst_mask */
2096 FALSE), /* pcrel_offset */
2097 HOWTO (R_NDS32_PTR_RESOLVED, /* type */
2098 0, /* rightshift */
2099 2, /* size (0 = byte, 1 = short, 2 = long) */
2100 32, /* bitsize */
2101 FALSE, /* pc_relative */
2102 0, /* bitpos */
2103 complain_overflow_dont,/* complain_on_overflow */
2104 nds32_elf_ignore_reloc,/* special_function */
2105 "R_NDS32_PTR_RESOLVED",/* name */
2106 FALSE, /* partial_inplace */
2107 0xffffffff, /* src_mask */
2108 0xffffffff, /* dst_mask */
2109 FALSE), /* pcrel_offset */
2110 HOWTO (R_NDS32_PLTBLOCK, /* type */
2111 0, /* rightshift */
2112 2, /* size (0 = byte, 1 = short, 2 = long) */
2113 32, /* bitsize */
2114 FALSE, /* pc_relative */
2115 0, /* bitpos */
2116 complain_overflow_dont,/* complain_on_overflow */
2117 nds32_elf_ignore_reloc,/* special_function */
2118 "R_NDS32_PLTBLOCK", /* name */
2119 FALSE, /* partial_inplace */
2120 0xffffffff, /* src_mask */
2121 0xffffffff, /* dst_mask */
2122 FALSE), /* pcrel_offset */
2123 HOWTO (R_NDS32_RELAX_REGION_BEGIN, /* type */
2124 0, /* rightshift */
2125 2, /* size (0 = byte, 1 = short, 2 = long) */
2126 32, /* bitsize */
2127 FALSE, /* pc_relative */
2128 0, /* bitpos */
2129 complain_overflow_dont,/* complain_on_overflow */
2130 nds32_elf_ignore_reloc,/* special_function */
2131 "R_NDS32_RELAX_REGION_BEGIN", /* name */
2132 FALSE, /* partial_inplace */
2133 0xffffffff, /* src_mask */
2134 0xffffffff, /* dst_mask */
2135 FALSE), /* pcrel_offset */
2136 HOWTO (R_NDS32_RELAX_REGION_END, /* type */
2137 0, /* rightshift */
2138 2, /* size (0 = byte, 1 = short, 2 = long) */
2139 32, /* bitsize */
2140 FALSE, /* pc_relative */
2141 0, /* bitpos */
2142 complain_overflow_dont,/* complain_on_overflow */
2143 nds32_elf_ignore_reloc,/* special_function */
2144 "R_NDS32_RELAX_REGION_END", /* name */
2145 FALSE, /* partial_inplace */
2146 0xffffffff, /* src_mask */
2147 0xffffffff, /* dst_mask */
2148 FALSE), /* pcrel_offset */
2149 HOWTO (R_NDS32_MINUEND, /* type */
2150 0, /* rightshift */
2151 2, /* size (0 = byte, 1 = short, 2 = long) */
2152 32, /* bitsize */
2153 FALSE, /* pc_relative */
2154 0, /* bitpos */
2155 complain_overflow_dont,/* complain_on_overflow */
2156 nds32_elf_ignore_reloc,/* special_function */
2157 "R_NDS32_MINUEND", /* name */
2158 FALSE, /* partial_inplace */
2159 0xffffffff, /* src_mask */
2160 0xffffffff, /* dst_mask */
2161 FALSE), /* pcrel_offset */
2162 HOWTO (R_NDS32_SUBTRAHEND, /* type */
2163 0, /* rightshift */
2164 2, /* size (0 = byte, 1 = short, 2 = long) */
2165 32, /* bitsize */
2166 FALSE, /* pc_relative */
2167 0, /* bitpos */
2168 complain_overflow_dont,/* complain_on_overflow */
2169 nds32_elf_ignore_reloc,/* special_function */
2170 "R_NDS32_SUBTRAHEND", /* name */
2171 FALSE, /* partial_inplace */
2172 0xffffffff, /* src_mask */
2173 0xffffffff, /* dst_mask */
2174 FALSE), /* pcrel_offset */
2175 HOWTO (R_NDS32_DIFF8, /* type */
2176 0, /* rightshift */
2177 0, /* size (0 = byte, 1 = short, 2 = long) */
2178 8, /* bitsize */
2179 FALSE, /* pc_relative */
2180 0, /* bitpos */
2181 complain_overflow_dont,/* complain_on_overflow */
2182 nds32_elf_ignore_reloc,/* special_function */
2183 "R_NDS32_DIFF8", /* name */
2184 FALSE, /* partial_inplace */
2185 0x000000ff, /* src_mask */
2186 0x000000ff, /* dst_mask */
2187 FALSE), /* pcrel_offset */
2188 HOWTO (R_NDS32_DIFF16, /* type */
2189 0, /* rightshift */
2190 1, /* size (0 = byte, 1 = short, 2 = long) */
2191 16, /* bitsize */
2192 FALSE, /* pc_relative */
2193 0, /* bitpos */
2194 complain_overflow_dont,/* complain_on_overflow */
2195 nds32_elf_ignore_reloc,/* special_function */
2196 "R_NDS32_DIFF16", /* name */
2197 FALSE, /* partial_inplace */
2198 0x0000ffff, /* src_mask */
2199 0x0000ffff, /* dst_mask */
2200 FALSE), /* pcrel_offset */
2201 HOWTO (R_NDS32_DIFF32, /* type */
2202 0, /* rightshift */
2203 2, /* size (0 = byte, 1 = short, 2 = long) */
2204 32, /* bitsize */
2205 FALSE, /* pc_relative */
2206 0, /* bitpos */
2207 complain_overflow_dont,/* complain_on_overflow */
2208 nds32_elf_ignore_reloc,/* special_function */
2209 "R_NDS32_DIFF32", /* name */
2210 FALSE, /* partial_inplace */
2211 0xffffffff, /* src_mask */
2212 0xffffffff, /* dst_mask */
2213 FALSE), /* pcrel_offset */
2214 HOWTO (R_NDS32_DIFF_ULEB128, /* type */
2215 0, /* rightshift */
2216 0, /* size (0 = byte, 1 = short, 2 = long) */
2217 0, /* bitsize */
2218 FALSE, /* pc_relative */
2219 0, /* bitpos */
2220 complain_overflow_dont,/* complain_on_overflow */
2221 nds32_elf_ignore_reloc,/* special_function */
2222 "R_NDS32_DIFF_ULEB128",/* name */
2223 FALSE, /* partial_inplace */
2224 0xffffffff, /* src_mask */
2225 0xffffffff, /* dst_mask */
2226 FALSE), /* pcrel_offset */
2227 HOWTO (R_NDS32_DATA, /* type */
2228 0, /* rightshift */
2229 2, /* size (0 = byte, 1 = short, 2 = long) */
2230 32, /* bitsize */
2231 FALSE, /* pc_relative */
2232 0, /* bitpos */
2233 complain_overflow_dont,/* complain_on_overflow */
2234 nds32_elf_ignore_reloc,/* special_function */
2235 "R_NDS32_DATA", /* name */
2236 FALSE, /* partial_inplace */
2237 0xffffffff, /* src_mask */
2238 0xffffffff, /* dst_mask */
2239 FALSE), /* pcrel_offset */
2240 HOWTO (R_NDS32_TRAN, /* type */
2241 0, /* rightshift */
2242 2, /* size (0 = byte, 1 = short, 2 = long) */
2243 32, /* bitsize */
2244 FALSE, /* pc_relative */
2245 0, /* bitpos */
2246 complain_overflow_dont,/* complain_on_overflow */
2247 nds32_elf_ignore_reloc,/* special_function */
2248 "R_NDS32_TRAN", /* name */
2249 FALSE, /* partial_inplace */
2250 0xffffffff, /* src_mask */
2251 0xffffffff, /* dst_mask */
2252 FALSE), /* pcrel_offset */
2253 HOWTO (R_NDS32_TLS_LE_ADD, /* type */
2254 0, /* rightshift */
2255 2, /* size (0 = byte, 1 = short, 2 = long) */
2256 32, /* bitsize */
2257 FALSE, /* pc_relative */
2258 0, /* bitpos */
2259 complain_overflow_dont, /* complain_on_overflow */
2260 nds32_elf_ignore_reloc, /* special_function */
2261 "R_NDS32_TLS_LE_ADD", /* name */
2262 FALSE, /* partial_inplace */
2263 0xffffffff, /* src_mask */
2264 0xffffffff, /* dst_mask */
2265 FALSE), /* pcrel_offset */
2266 HOWTO (R_NDS32_TLS_LE_LS, /* type */
2267 0, /* rightshift */
2268 2, /* size (0 = byte, 1 = short, 2 = long) */
2269 32, /* bitsize */
2270 FALSE, /* pc_relative */
2271 0, /* bitpos */
2272 complain_overflow_dont, /* complain_on_overflow */
2273 nds32_elf_ignore_reloc, /* special_function */
2274 "R_NDS32_TLS_LE_LS", /* name */
2275 FALSE, /* partial_inplace */
2276 0xffffffff, /* src_mask */
2277 0xffffffff, /* dst_mask */
2278 FALSE), /* pcrel_offset */
2279 HOWTO (R_NDS32_EMPTY, /* type */
2280 0, /* rightshift */
2281 2, /* size (0 = byte, 1 = short, 2 = long) */
2282 32, /* bitsize */
2283 FALSE, /* pc_relative */
2284 0, /* bitpos */
2285 complain_overflow_dont, /* complain_on_overflow */
2286 nds32_elf_ignore_reloc, /* special_function */
2287 "R_NDS32_EMPTY", /* name */
2288 FALSE, /* partial_inplace */
2289 0xffffffff, /* src_mask */
2290 0xffffffff, /* dst_mask */
2291 FALSE), /* pcrel_offset */
2292 };
2293
2294 \f
2295 /* nds32_insertion_sort sorts an array with nmemb elements of size size.
2296 This prototype is the same as qsort (). */
2297
2298 void
2299 nds32_insertion_sort (void *base, size_t nmemb, size_t size,
2300 int (*compar) (const void *lhs, const void *rhs))
2301 {
2302 char *ptr = (char *) base;
2303 int i, j;
2304 char *tmp = xmalloc (size);
2305
2306 /* If i is less than j, i is inserted before j.
2307
2308 |---- j ----- i --------------|
2309 \ / \ /
2310 sorted unsorted
2311 */
2312
2313 for (i = 1; i < (int) nmemb; i++)
2314 {
2315 for (j = (i - 1); j >= 0; j--)
2316 if (compar (ptr + i * size, ptr + j * size) >= 0)
2317 break;
2318
2319 j++;
2320
2321 if (i == j)
2322 continue; /* i is in order. */
2323
2324 memcpy (tmp, ptr + i * size, size);
2325 memmove (ptr + (j + 1) * size, ptr + j * size, (i - j) * size);
2326 memcpy (ptr + j * size, tmp, size);
2327 }
2328 free (tmp);
2329 }
2330
2331 /* Sort relocation by r_offset.
2332
2333 We didn't use qsort () in stdlib, because quick-sort is not a stable sorting
2334 algorithm. Relocations at the same r_offset must keep their order.
2335 For example, RELAX_ENTRY must be the very first relocation entry.
2336
2337 Currently, this function implements insertion-sort.
2338
2339 FIXME: If we already sort them in assembler, why bother sort them
2340 here again? */
2341
2342 static int
2343 compar_reloc (const void *lhs, const void *rhs)
2344 {
2345 const Elf_Internal_Rela *l = (const Elf_Internal_Rela *) lhs;
2346 const Elf_Internal_Rela *r = (const Elf_Internal_Rela *) rhs;
2347
2348 if (l->r_offset > r->r_offset)
2349 return 1;
2350 else if (l->r_offset == r->r_offset)
2351 return 0;
2352 else
2353 return -1;
2354 }
2355
2356 /* Functions listed below are only used for old relocs.
2357 * nds32_elf_9_pcrel_reloc
2358 * nds32_elf_do_9_pcrel_reloc
2359 * nds32_elf_hi20_reloc
2360 * nds32_elf_relocate_hi20
2361 * nds32_elf_lo12_reloc
2362 * nds32_elf_sda15_reloc
2363 * nds32_elf_generic_reloc
2364 */
2365
2366 /* Handle the R_NDS32_9_PCREL & R_NDS32_9_PCREL_RELA reloc. */
2367
2368 static bfd_reloc_status_type
2369 nds32_elf_9_pcrel_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2370 void *data, asection *input_section, bfd *output_bfd,
2371 char **error_message ATTRIBUTE_UNUSED)
2372 {
2373 /* This part is from bfd_elf_generic_reloc. */
2374 if (output_bfd != (bfd *) NULL
2375 && (symbol->flags & BSF_SECTION_SYM) == 0
2376 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2377 {
2378 reloc_entry->address += input_section->output_offset;
2379 return bfd_reloc_ok;
2380 }
2381
2382 if (output_bfd != NULL)
2383 {
2384 /* FIXME: See bfd_perform_relocation. Is this right? */
2385 return bfd_reloc_continue;
2386 }
2387
2388 return nds32_elf_do_9_pcrel_reloc (abfd, reloc_entry->howto,
2389 input_section,
2390 data, reloc_entry->address,
2391 symbol->section,
2392 (symbol->value
2393 + symbol->section->output_section->vma
2394 + symbol->section->output_offset),
2395 reloc_entry->addend);
2396 }
2397
2398 /* Utility to actually perform an R_NDS32_9_PCREL reloc. */
2399 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
2400
2401 static bfd_reloc_status_type
2402 nds32_elf_do_9_pcrel_reloc (bfd *abfd, reloc_howto_type *howto,
2403 asection *input_section, bfd_byte *data,
2404 bfd_vma offset,
2405 asection *symbol_section ATTRIBUTE_UNUSED,
2406 bfd_vma symbol_value, bfd_vma addend)
2407 {
2408 bfd_signed_vma relocation;
2409 unsigned short x;
2410 bfd_reloc_status_type status;
2411
2412 /* Sanity check the address (offset in section). */
2413 if (offset > bfd_get_section_limit (abfd, input_section))
2414 return bfd_reloc_outofrange;
2415
2416 relocation = symbol_value + addend;
2417 /* Make it pc relative. */
2418 relocation -= (input_section->output_section->vma
2419 + input_section->output_offset);
2420 /* These jumps mask off the lower two bits of the current address
2421 before doing pcrel calculations. */
2422 relocation -= (offset & -(bfd_vma) 2);
2423
2424 if (relocation < -ACCURATE_8BIT_S1 || relocation >= ACCURATE_8BIT_S1)
2425 status = bfd_reloc_overflow;
2426 else
2427 status = bfd_reloc_ok;
2428
2429 x = bfd_getb16 (data + offset);
2430
2431 relocation >>= howto->rightshift;
2432 relocation <<= howto->bitpos;
2433 x = (x & ~howto->dst_mask)
2434 | (((x & howto->src_mask) + relocation) & howto->dst_mask);
2435
2436 bfd_putb16 ((bfd_vma) x, data + offset);
2437
2438 return status;
2439 }
2440
2441 /* Handle the R_NDS32_HI20_[SU]LO relocs.
2442 HI20_SLO is for the add3 and load/store with displacement instructions.
2443 HI20 is for the or3 instruction.
2444 For R_NDS32_HI20_SLO, the lower 16 bits are sign extended when added to
2445 the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
2446 we must add one to the high 16 bytes (which will get subtracted off when
2447 the low 16 bits are added).
2448 These relocs have to be done in combination with an R_NDS32_LO12 reloc
2449 because there is a carry from the LO12 to the HI20. Here we just save
2450 the information we need; we do the actual relocation when we see the LO12.
2451 This code is copied from the elf32-mips.c. We also support an arbitrary
2452 number of HI20 relocs to be associated with a single LO12 reloc. The
2453 assembler sorts the relocs to ensure each HI20 immediately precedes its
2454 LO12. However if there are multiple copies, the assembler may not find
2455 the real LO12 so it picks the first one it finds. */
2456
2457 struct nds32_hi20
2458 {
2459 struct nds32_hi20 *next;
2460 bfd_byte *addr;
2461 bfd_vma addend;
2462 };
2463
2464 static struct nds32_hi20 *nds32_hi20_list;
2465
2466 static bfd_reloc_status_type
2467 nds32_elf_hi20_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2468 asymbol *symbol, void *data, asection *input_section,
2469 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2470 {
2471 bfd_reloc_status_type ret;
2472 bfd_vma relocation;
2473 struct nds32_hi20 *n;
2474
2475 /* This part is from bfd_elf_generic_reloc.
2476 If we're relocating, and this an external symbol, we don't want
2477 to change anything. */
2478 if (output_bfd != (bfd *) NULL
2479 && (symbol->flags & BSF_SECTION_SYM) == 0 && reloc_entry->addend == 0)
2480 {
2481 reloc_entry->address += input_section->output_offset;
2482 return bfd_reloc_ok;
2483 }
2484
2485 /* Sanity check the address (offset in section). */
2486 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2487 return bfd_reloc_outofrange;
2488
2489 ret = bfd_reloc_ok;
2490 if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2491 ret = bfd_reloc_undefined;
2492
2493 if (bfd_is_com_section (symbol->section))
2494 relocation = 0;
2495 else
2496 relocation = symbol->value;
2497
2498 relocation += symbol->section->output_section->vma;
2499 relocation += symbol->section->output_offset;
2500 relocation += reloc_entry->addend;
2501
2502 /* Save the information, and let LO12 do the actual relocation. */
2503 n = (struct nds32_hi20 *) bfd_malloc ((bfd_size_type) sizeof *n);
2504 if (n == NULL)
2505 return bfd_reloc_outofrange;
2506
2507 n->addr = (bfd_byte *) data + reloc_entry->address;
2508 n->addend = relocation;
2509 n->next = nds32_hi20_list;
2510 nds32_hi20_list = n;
2511
2512 if (output_bfd != (bfd *) NULL)
2513 reloc_entry->address += input_section->output_offset;
2514
2515 return ret;
2516 }
2517
2518 /* Handle an NDS32 ELF HI20 reloc. */
2519
2520 static void
2521 nds32_elf_relocate_hi20 (bfd *input_bfd ATTRIBUTE_UNUSED,
2522 int type ATTRIBUTE_UNUSED, Elf_Internal_Rela *relhi,
2523 Elf_Internal_Rela *rello, bfd_byte *contents,
2524 bfd_vma addend)
2525 {
2526 unsigned long insn;
2527 bfd_vma addlo;
2528
2529 insn = bfd_getb32 (contents + relhi->r_offset);
2530
2531 addlo = bfd_getb32 (contents + rello->r_offset);
2532 addlo &= 0xfff;
2533
2534 addend += ((insn & 0xfffff) << 20) + addlo;
2535
2536 insn = (insn & 0xfff00000) | ((addend >> 12) & 0xfffff);
2537 bfd_putb32 (insn, contents + relhi->r_offset);
2538 }
2539
2540 /* Do an R_NDS32_LO12 relocation. This is a straightforward 12 bit
2541 inplace relocation; this function exists in order to do the
2542 R_NDS32_HI20_[SU]LO relocation described above. */
2543
2544 static bfd_reloc_status_type
2545 nds32_elf_lo12_reloc (bfd *input_bfd, arelent *reloc_entry, asymbol *symbol,
2546 void *data, asection *input_section, bfd *output_bfd,
2547 char **error_message)
2548 {
2549 /* This part is from bfd_elf_generic_reloc.
2550 If we're relocating, and this an external symbol, we don't want
2551 to change anything. */
2552 if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2553 && reloc_entry->addend == 0)
2554 {
2555 reloc_entry->address += input_section->output_offset;
2556 return bfd_reloc_ok;
2557 }
2558
2559 if (nds32_hi20_list != NULL)
2560 {
2561 struct nds32_hi20 *l;
2562
2563 l = nds32_hi20_list;
2564 while (l != NULL)
2565 {
2566 unsigned long insn;
2567 unsigned long val;
2568 unsigned long vallo;
2569 struct nds32_hi20 *next;
2570
2571 /* Do the HI20 relocation. Note that we actually don't need
2572 to know anything about the LO12 itself, except where to
2573 find the low 12 bits of the addend needed by the LO12. */
2574 insn = bfd_getb32 (l->addr);
2575 vallo = bfd_getb32 ((bfd_byte *) data + reloc_entry->address);
2576 vallo &= 0xfff;
2577 switch (reloc_entry->howto->type)
2578 {
2579 case R_NDS32_LO12S3:
2580 vallo <<= 3;
2581 break;
2582
2583 case R_NDS32_LO12S2:
2584 vallo <<= 2;
2585 break;
2586
2587 case R_NDS32_LO12S1:
2588 vallo <<= 1;
2589 break;
2590
2591 case R_NDS32_LO12S0:
2592 vallo <<= 0;
2593 break;
2594 }
2595
2596 val = ((insn & 0xfffff) << 12) + vallo;
2597 val += l->addend;
2598
2599 insn = (insn & ~(bfd_vma) 0xfffff) | ((val >> 12) & 0xfffff);
2600 bfd_putb32 ((bfd_vma) insn, l->addr);
2601
2602 next = l->next;
2603 free (l);
2604 l = next;
2605 }
2606
2607 nds32_hi20_list = NULL;
2608 }
2609
2610 /* Now do the LO12 reloc in the usual way.
2611 ??? It would be nice to call bfd_elf_generic_reloc here,
2612 but we have partial_inplace set. bfd_elf_generic_reloc will
2613 pass the handling back to bfd_install_relocation which will install
2614 a section relative addend which is wrong. */
2615 return nds32_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
2616 input_section, output_bfd, error_message);
2617 }
2618
2619 /* Do generic partial_inplace relocation.
2620 This is a local replacement for bfd_elf_generic_reloc. */
2621
2622 static bfd_reloc_status_type
2623 nds32_elf_generic_reloc (bfd *input_bfd, arelent *reloc_entry,
2624 asymbol *symbol, void *data, asection *input_section,
2625 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2626 {
2627 bfd_reloc_status_type ret;
2628 bfd_vma relocation;
2629 bfd_byte *inplace_address;
2630
2631 /* This part is from bfd_elf_generic_reloc.
2632 If we're relocating, and this an external symbol, we don't want
2633 to change anything. */
2634 if (output_bfd != NULL && (symbol->flags & BSF_SECTION_SYM) == 0
2635 && reloc_entry->addend == 0)
2636 {
2637 reloc_entry->address += input_section->output_offset;
2638 return bfd_reloc_ok;
2639 }
2640
2641 /* Now do the reloc in the usual way.
2642 ??? It would be nice to call bfd_elf_generic_reloc here,
2643 but we have partial_inplace set. bfd_elf_generic_reloc will
2644 pass the handling back to bfd_install_relocation which will install
2645 a section relative addend which is wrong. */
2646
2647 /* Sanity check the address (offset in section). */
2648 if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section))
2649 return bfd_reloc_outofrange;
2650
2651 ret = bfd_reloc_ok;
2652 if (bfd_is_und_section (symbol->section) && output_bfd == (bfd *) NULL)
2653 ret = bfd_reloc_undefined;
2654
2655 if (bfd_is_com_section (symbol->section) || output_bfd != (bfd *) NULL)
2656 relocation = 0;
2657 else
2658 relocation = symbol->value;
2659
2660 /* Only do this for a final link. */
2661 if (output_bfd == (bfd *) NULL)
2662 {
2663 relocation += symbol->section->output_section->vma;
2664 relocation += symbol->section->output_offset;
2665 }
2666
2667 relocation += reloc_entry->addend;
2668 switch (reloc_entry->howto->type)
2669 {
2670 case R_NDS32_LO12S3:
2671 relocation >>= 3;
2672 break;
2673
2674 case R_NDS32_LO12S2:
2675 relocation >>= 2;
2676 break;
2677
2678 case R_NDS32_LO12S1:
2679 relocation >>= 1;
2680 break;
2681
2682 case R_NDS32_LO12S0:
2683 default:
2684 relocation >>= 0;
2685 break;
2686 }
2687
2688 inplace_address = (bfd_byte *) data + reloc_entry->address;
2689
2690 #define DOIT(x) \
2691 x = ((x & ~reloc_entry->howto->dst_mask) | \
2692 (((x & reloc_entry->howto->src_mask) + relocation) & \
2693 reloc_entry->howto->dst_mask))
2694
2695 switch (reloc_entry->howto->size)
2696 {
2697 case 1:
2698 {
2699 short x = bfd_getb16 (inplace_address);
2700
2701 DOIT (x);
2702 bfd_putb16 ((bfd_vma) x, inplace_address);
2703 }
2704 break;
2705 case 2:
2706 {
2707 unsigned long x = bfd_getb32 (inplace_address);
2708
2709 DOIT (x);
2710 bfd_putb32 ((bfd_vma) x, inplace_address);
2711 }
2712 break;
2713 default:
2714 BFD_ASSERT (0);
2715 }
2716
2717 if (output_bfd != (bfd *) NULL)
2718 reloc_entry->address += input_section->output_offset;
2719
2720 return ret;
2721 }
2722
2723 /* Handle the R_NDS32_SDA15 reloc.
2724 This reloc is used to compute the address of objects in the small data area
2725 and to perform loads and stores from that area.
2726 The lower 15 bits are sign extended and added to the register specified
2727 in the instruction, which is assumed to point to _SDA_BASE_.
2728
2729 Since the lower 15 bits offset is left-shifted 0, 1 or 2 bits depending on
2730 the access size, this must be taken care of. */
2731
2732 static bfd_reloc_status_type
2733 nds32_elf_sda15_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2734 asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2735 asection *input_section, bfd *output_bfd,
2736 char **error_message ATTRIBUTE_UNUSED)
2737 {
2738 /* This part is from bfd_elf_generic_reloc. */
2739 if (output_bfd != (bfd *) NULL
2740 && (symbol->flags & BSF_SECTION_SYM) == 0
2741 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
2742 {
2743 reloc_entry->address += input_section->output_offset;
2744 return bfd_reloc_ok;
2745 }
2746
2747 if (output_bfd != NULL)
2748 {
2749 /* FIXME: See bfd_perform_relocation. Is this right? */
2750 return bfd_reloc_continue;
2751 }
2752
2753 /* FIXME: not sure what to do here yet. But then again, the linker
2754 may never call us. */
2755 abort ();
2756 }
2757
2758 /* nds32_elf_ignore_reloc is the special function for
2759 relocation types which don't need to be relocated
2760 like relaxation relocation types.
2761 This function simply return bfd_reloc_ok when it is
2762 invoked. */
2763
2764 static bfd_reloc_status_type
2765 nds32_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2766 asymbol *symbol ATTRIBUTE_UNUSED,
2767 void *data ATTRIBUTE_UNUSED, asection *input_section,
2768 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
2769 {
2770 if (output_bfd != NULL)
2771 reloc_entry->address += input_section->output_offset;
2772
2773 return bfd_reloc_ok;
2774 }
2775 \f
2776
2777 /* Map BFD reloc types to NDS32 ELF reloc types. */
2778
2779 struct nds32_reloc_map_entry
2780 {
2781 bfd_reloc_code_real_type bfd_reloc_val;
2782 unsigned char elf_reloc_val;
2783 };
2784
2785 static const struct nds32_reloc_map_entry nds32_reloc_map[] =
2786 {
2787 {BFD_RELOC_NONE, R_NDS32_NONE},
2788 {BFD_RELOC_16, R_NDS32_16_RELA},
2789 {BFD_RELOC_32, R_NDS32_32_RELA},
2790 {BFD_RELOC_NDS32_20, R_NDS32_20_RELA},
2791 {BFD_RELOC_NDS32_5, R_NDS32_5_RELA},
2792 {BFD_RELOC_NDS32_9_PCREL, R_NDS32_9_PCREL_RELA},
2793 {BFD_RELOC_NDS32_WORD_9_PCREL, R_NDS32_WORD_9_PCREL_RELA},
2794 {BFD_RELOC_NDS32_15_PCREL, R_NDS32_15_PCREL_RELA},
2795 {BFD_RELOC_NDS32_17_PCREL, R_NDS32_17_PCREL_RELA},
2796 {BFD_RELOC_NDS32_25_PCREL, R_NDS32_25_PCREL_RELA},
2797 {BFD_RELOC_NDS32_10_UPCREL, R_NDS32_10_UPCREL_RELA},
2798 {BFD_RELOC_NDS32_HI20, R_NDS32_HI20_RELA},
2799 {BFD_RELOC_NDS32_LO12S3, R_NDS32_LO12S3_RELA},
2800 {BFD_RELOC_NDS32_LO12S2, R_NDS32_LO12S2_RELA},
2801 {BFD_RELOC_NDS32_LO12S1, R_NDS32_LO12S1_RELA},
2802 {BFD_RELOC_NDS32_LO12S0, R_NDS32_LO12S0_RELA},
2803 {BFD_RELOC_NDS32_LO12S0_ORI, R_NDS32_LO12S0_ORI_RELA},
2804 {BFD_RELOC_NDS32_SDA15S3, R_NDS32_SDA15S3_RELA},
2805 {BFD_RELOC_NDS32_SDA15S2, R_NDS32_SDA15S2_RELA},
2806 {BFD_RELOC_NDS32_SDA15S1, R_NDS32_SDA15S1_RELA},
2807 {BFD_RELOC_NDS32_SDA15S0, R_NDS32_SDA15S0_RELA},
2808 {BFD_RELOC_VTABLE_INHERIT, R_NDS32_RELA_GNU_VTINHERIT},
2809 {BFD_RELOC_VTABLE_ENTRY, R_NDS32_RELA_GNU_VTENTRY},
2810
2811 {BFD_RELOC_NDS32_GOT20, R_NDS32_GOT20},
2812 {BFD_RELOC_NDS32_9_PLTREL, R_NDS32_9_PLTREL},
2813 {BFD_RELOC_NDS32_25_PLTREL, R_NDS32_25_PLTREL},
2814 {BFD_RELOC_NDS32_COPY, R_NDS32_COPY},
2815 {BFD_RELOC_NDS32_GLOB_DAT, R_NDS32_GLOB_DAT},
2816 {BFD_RELOC_NDS32_JMP_SLOT, R_NDS32_JMP_SLOT},
2817 {BFD_RELOC_NDS32_RELATIVE, R_NDS32_RELATIVE},
2818 {BFD_RELOC_NDS32_GOTOFF, R_NDS32_GOTOFF},
2819 {BFD_RELOC_NDS32_GOTPC20, R_NDS32_GOTPC20},
2820 {BFD_RELOC_NDS32_GOT_HI20, R_NDS32_GOT_HI20},
2821 {BFD_RELOC_NDS32_GOT_LO12, R_NDS32_GOT_LO12},
2822 {BFD_RELOC_NDS32_GOT_LO15, R_NDS32_GOT_LO15},
2823 {BFD_RELOC_NDS32_GOT_LO19, R_NDS32_GOT_LO19},
2824 {BFD_RELOC_NDS32_GOTPC_HI20, R_NDS32_GOTPC_HI20},
2825 {BFD_RELOC_NDS32_GOTPC_LO12, R_NDS32_GOTPC_LO12},
2826 {BFD_RELOC_NDS32_GOTOFF_HI20, R_NDS32_GOTOFF_HI20},
2827 {BFD_RELOC_NDS32_GOTOFF_LO12, R_NDS32_GOTOFF_LO12},
2828 {BFD_RELOC_NDS32_GOTOFF_LO15, R_NDS32_GOTOFF_LO15},
2829 {BFD_RELOC_NDS32_GOTOFF_LO19, R_NDS32_GOTOFF_LO19},
2830 {BFD_RELOC_NDS32_INSN16, R_NDS32_INSN16},
2831 {BFD_RELOC_NDS32_LABEL, R_NDS32_LABEL},
2832 {BFD_RELOC_NDS32_LONGCALL1, R_NDS32_LONGCALL1},
2833 {BFD_RELOC_NDS32_LONGCALL2, R_NDS32_LONGCALL2},
2834 {BFD_RELOC_NDS32_LONGCALL3, R_NDS32_LONGCALL3},
2835 {BFD_RELOC_NDS32_LONGCALL4, R_NDS32_LONGCALL4},
2836 {BFD_RELOC_NDS32_LONGCALL5, R_NDS32_LONGCALL5},
2837 {BFD_RELOC_NDS32_LONGCALL6, R_NDS32_LONGCALL6},
2838 {BFD_RELOC_NDS32_LONGJUMP1, R_NDS32_LONGJUMP1},
2839 {BFD_RELOC_NDS32_LONGJUMP2, R_NDS32_LONGJUMP2},
2840 {BFD_RELOC_NDS32_LONGJUMP3, R_NDS32_LONGJUMP3},
2841 {BFD_RELOC_NDS32_LONGJUMP4, R_NDS32_LONGJUMP4},
2842 {BFD_RELOC_NDS32_LONGJUMP5, R_NDS32_LONGJUMP5},
2843 {BFD_RELOC_NDS32_LONGJUMP6, R_NDS32_LONGJUMP6},
2844 {BFD_RELOC_NDS32_LONGJUMP7, R_NDS32_LONGJUMP7},
2845 {BFD_RELOC_NDS32_LOADSTORE, R_NDS32_LOADSTORE},
2846 {BFD_RELOC_NDS32_9_FIXED, R_NDS32_9_FIXED_RELA},
2847 {BFD_RELOC_NDS32_15_FIXED, R_NDS32_15_FIXED_RELA},
2848 {BFD_RELOC_NDS32_17_FIXED, R_NDS32_17_FIXED_RELA},
2849 {BFD_RELOC_NDS32_25_FIXED, R_NDS32_25_FIXED_RELA},
2850 {BFD_RELOC_NDS32_PLTREL_HI20, R_NDS32_PLTREL_HI20},
2851 {BFD_RELOC_NDS32_PLTREL_LO12, R_NDS32_PLTREL_LO12},
2852 {BFD_RELOC_NDS32_PLT_GOTREL_HI20, R_NDS32_PLT_GOTREL_HI20},
2853 {BFD_RELOC_NDS32_PLT_GOTREL_LO12, R_NDS32_PLT_GOTREL_LO12},
2854 {BFD_RELOC_NDS32_PLT_GOTREL_LO15, R_NDS32_PLT_GOTREL_LO15},
2855 {BFD_RELOC_NDS32_PLT_GOTREL_LO19, R_NDS32_PLT_GOTREL_LO19},
2856 {BFD_RELOC_NDS32_PLT_GOTREL_LO20, R_NDS32_PLT_GOTREL_LO20},
2857 {BFD_RELOC_NDS32_SDA12S2_DP, R_NDS32_SDA12S2_DP_RELA},
2858 {BFD_RELOC_NDS32_SDA12S2_SP, R_NDS32_SDA12S2_SP_RELA},
2859 {BFD_RELOC_NDS32_LO12S2_DP, R_NDS32_LO12S2_DP_RELA},
2860 {BFD_RELOC_NDS32_LO12S2_SP, R_NDS32_LO12S2_SP_RELA},
2861 {BFD_RELOC_NDS32_SDA16S3, R_NDS32_SDA16S3_RELA},
2862 {BFD_RELOC_NDS32_SDA17S2, R_NDS32_SDA17S2_RELA},
2863 {BFD_RELOC_NDS32_SDA18S1, R_NDS32_SDA18S1_RELA},
2864 {BFD_RELOC_NDS32_SDA19S0, R_NDS32_SDA19S0_RELA},
2865 {BFD_RELOC_NDS32_SDA_FP7U2_RELA, R_NDS32_SDA_FP7U2_RELA},
2866 {BFD_RELOC_NDS32_DWARF2_OP1, R_NDS32_DWARF2_OP1_RELA},
2867 {BFD_RELOC_NDS32_DWARF2_OP2, R_NDS32_DWARF2_OP2_RELA},
2868 {BFD_RELOC_NDS32_DWARF2_LEB, R_NDS32_DWARF2_LEB_RELA},
2869 {BFD_RELOC_NDS32_UPDATE_TA, R_NDS32_UPDATE_TA_RELA},
2870 {BFD_RELOC_NDS32_GOT_SUFF, R_NDS32_GOT_SUFF},
2871 {BFD_RELOC_NDS32_GOTOFF_SUFF, R_NDS32_GOTOFF_SUFF},
2872 {BFD_RELOC_NDS32_GOT15S2, R_NDS32_GOT15S2_RELA},
2873 {BFD_RELOC_NDS32_GOT17S2, R_NDS32_GOT17S2_RELA},
2874 {BFD_RELOC_NDS32_PTR, R_NDS32_PTR},
2875 {BFD_RELOC_NDS32_PTR_COUNT, R_NDS32_PTR_COUNT},
2876 {BFD_RELOC_NDS32_PLT_GOT_SUFF, R_NDS32_PLT_GOT_SUFF},
2877 {BFD_RELOC_NDS32_PTR_RESOLVED, R_NDS32_PTR_RESOLVED},
2878 {BFD_RELOC_NDS32_RELAX_ENTRY, R_NDS32_RELAX_ENTRY},
2879 {BFD_RELOC_NDS32_MULCALL_SUFF, R_NDS32_MULCALL_SUFF},
2880 {BFD_RELOC_NDS32_PLTBLOCK, R_NDS32_PLTBLOCK},
2881 {BFD_RELOC_NDS32_RELAX_REGION_BEGIN, R_NDS32_RELAX_REGION_BEGIN},
2882 {BFD_RELOC_NDS32_RELAX_REGION_END, R_NDS32_RELAX_REGION_END},
2883 {BFD_RELOC_NDS32_MINUEND, R_NDS32_MINUEND},
2884 {BFD_RELOC_NDS32_SUBTRAHEND, R_NDS32_SUBTRAHEND},
2885 {BFD_RELOC_NDS32_EMPTY, R_NDS32_EMPTY},
2886
2887 {BFD_RELOC_NDS32_DIFF8, R_NDS32_DIFF8},
2888 {BFD_RELOC_NDS32_DIFF16, R_NDS32_DIFF16},
2889 {BFD_RELOC_NDS32_DIFF32, R_NDS32_DIFF32},
2890 {BFD_RELOC_NDS32_DIFF_ULEB128, R_NDS32_DIFF_ULEB128},
2891 {BFD_RELOC_NDS32_25_ABS, R_NDS32_25_ABS_RELA},
2892 {BFD_RELOC_NDS32_DATA, R_NDS32_DATA},
2893 {BFD_RELOC_NDS32_TRAN, R_NDS32_TRAN},
2894 {BFD_RELOC_NDS32_17IFC_PCREL, R_NDS32_17IFC_PCREL_RELA},
2895 {BFD_RELOC_NDS32_10IFCU_PCREL, R_NDS32_10IFCU_PCREL_RELA},
2896 {BFD_RELOC_NDS32_TLS_LE_HI20, R_NDS32_TLS_LE_HI20},
2897 {BFD_RELOC_NDS32_TLS_LE_LO12, R_NDS32_TLS_LE_LO12},
2898 {BFD_RELOC_NDS32_TLS_LE_ADD, R_NDS32_TLS_LE_ADD},
2899 {BFD_RELOC_NDS32_TLS_LE_LS, R_NDS32_TLS_LE_LS},
2900 {BFD_RELOC_NDS32_TLS_IE_HI20, R_NDS32_TLS_IE_HI20},
2901 {BFD_RELOC_NDS32_TLS_IE_LO12S2, R_NDS32_TLS_IE_LO12S2},
2902 {BFD_RELOC_NDS32_TLS_TPOFF, R_NDS32_TLS_TPOFF},
2903 {BFD_RELOC_NDS32_TLS_LE_20, R_NDS32_TLS_LE_20},
2904 {BFD_RELOC_NDS32_TLS_LE_15S0, R_NDS32_TLS_LE_15S0},
2905 {BFD_RELOC_NDS32_TLS_LE_15S1, R_NDS32_TLS_LE_15S1},
2906 {BFD_RELOC_NDS32_TLS_LE_15S2, R_NDS32_TLS_LE_15S2},
2907 };
2908
2909 /* Patch tag. */
2910
2911 static reloc_howto_type *
2912 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2913 const char *r_name)
2914 {
2915 unsigned int i;
2916
2917 for (i = 0; i < ARRAY_SIZE (nds32_elf_howto_table); i++)
2918 if (nds32_elf_howto_table[i].name != NULL
2919 && strcasecmp (nds32_elf_howto_table[i].name, r_name) == 0)
2920 return &nds32_elf_howto_table[i];
2921
2922 for (i = 0; i < ARRAY_SIZE (nds32_elf_relax_howto_table); i++)
2923 if (nds32_elf_relax_howto_table[i].name != NULL
2924 && strcasecmp (nds32_elf_relax_howto_table[i].name, r_name) == 0)
2925 return &nds32_elf_relax_howto_table[i];
2926
2927 return NULL;
2928 }
2929
2930 static reloc_howto_type *
2931 bfd_elf32_bfd_reloc_type_table_lookup (enum elf_nds32_reloc_type code)
2932 {
2933 if (code < R_NDS32_RELAX_ENTRY)
2934 {
2935 BFD_ASSERT (code < ARRAY_SIZE (nds32_elf_howto_table));
2936 return &nds32_elf_howto_table[code];
2937 }
2938 else
2939 {
2940 BFD_ASSERT ((size_t) (code - R_NDS32_RELAX_ENTRY)
2941 < ARRAY_SIZE (nds32_elf_relax_howto_table));
2942 return &nds32_elf_relax_howto_table[code - R_NDS32_RELAX_ENTRY];
2943 }
2944 }
2945
2946 static reloc_howto_type *
2947 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2948 bfd_reloc_code_real_type code)
2949 {
2950 unsigned int i;
2951
2952 for (i = 0; i < ARRAY_SIZE (nds32_reloc_map); i++)
2953 {
2954 if (nds32_reloc_map[i].bfd_reloc_val == code)
2955 return bfd_elf32_bfd_reloc_type_table_lookup
2956 (nds32_reloc_map[i].elf_reloc_val);
2957 }
2958
2959 return NULL;
2960 }
2961
2962 /* Set the howto pointer for an NDS32 ELF reloc. */
2963
2964 static void
2965 nds32_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2966 Elf_Internal_Rela *dst)
2967 {
2968 enum elf_nds32_reloc_type r_type;
2969
2970 r_type = ELF32_R_TYPE (dst->r_info);
2971 if (r_type > R_NDS32_GNU_VTENTRY)
2972 {
2973 _bfd_error_handler (_("%B: invalid NDS32 reloc number: %d"), abfd, r_type);
2974 r_type = 0;
2975 }
2976 cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
2977 }
2978
2979 static void
2980 nds32_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2981 Elf_Internal_Rela *dst)
2982 {
2983 BFD_ASSERT ((ELF32_R_TYPE (dst->r_info) == R_NDS32_NONE)
2984 || ((ELF32_R_TYPE (dst->r_info) > R_NDS32_GNU_VTENTRY)
2985 && (ELF32_R_TYPE (dst->r_info) < R_NDS32_max)));
2986 cache_ptr->howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (dst->r_info));
2987 }
2988
2989 /* Support for core dump NOTE sections.
2990 Reference to include/linux/elfcore.h in Linux. */
2991
2992 static bfd_boolean
2993 nds32_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2994 {
2995 int offset;
2996 size_t size;
2997
2998 switch (note->descsz)
2999 {
3000 case 0x114:
3001 /* Linux/NDS32 32-bit, ABI1 */
3002
3003 /* pr_cursig */
3004 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3005
3006 /* pr_pid */
3007 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3008
3009 /* pr_reg */
3010 offset = 72;
3011 size = 200;
3012 break;
3013
3014 case 0xfc:
3015 /* Linux/NDS32 32-bit */
3016
3017 /* pr_cursig */
3018 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3019
3020 /* pr_pid */
3021 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
3022
3023 /* pr_reg */
3024 offset = 72;
3025 size = 176;
3026 break;
3027
3028 default:
3029 return FALSE;
3030 }
3031
3032 /* Make a ".reg" section. */
3033 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3034 size, note->descpos + offset);
3035 }
3036
3037 static bfd_boolean
3038 nds32_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3039 {
3040 switch (note->descsz)
3041 {
3042 case 124:
3043 /* Linux/NDS32 */
3044
3045 /* __kernel_uid_t, __kernel_gid_t are short on NDS32 platform. */
3046 elf_tdata (abfd)->core->program =
3047 _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
3048 elf_tdata (abfd)->core->command =
3049 _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
3050 break;
3051
3052 default:
3053 return FALSE;
3054 }
3055
3056 /* Note that for some reason, a spurious space is tacked
3057 onto the end of the args in some (at least one anyway)
3058 implementations, so strip it off if it exists. */
3059 {
3060 char *command = elf_tdata (abfd)->core->command;
3061 int n = strlen (command);
3062
3063 if (0 < n && command[n - 1] == ' ')
3064 command[n - 1] = '\0';
3065 }
3066
3067 return TRUE;
3068 }
3069
3070 /* Hook called by the linker routine which adds symbols from an object
3071 file. We must handle the special NDS32 section numbers here.
3072 We also keep watching for whether we need to create the sdata special
3073 linker sections. */
3074
3075 static bfd_boolean
3076 nds32_elf_add_symbol_hook (bfd *abfd,
3077 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3078 Elf_Internal_Sym *sym,
3079 const char **namep ATTRIBUTE_UNUSED,
3080 flagword *flagsp ATTRIBUTE_UNUSED,
3081 asection **secp, bfd_vma *valp)
3082 {
3083 switch (sym->st_shndx)
3084 {
3085 case SHN_COMMON:
3086 /* Common symbols less than the GP size are automatically
3087 treated as SHN_MIPS_SCOMMON symbols. */
3088 if (sym->st_size > elf_gp_size (abfd)
3089 || ELF_ST_TYPE (sym->st_info) == STT_TLS)
3090 break;
3091
3092 /* st_value is the alignemnt constraint.
3093 That might be its actual size if it is an array or structure. */
3094 switch (sym->st_value)
3095 {
3096 case 1:
3097 *secp = bfd_make_section_old_way (abfd, ".scommon_b");
3098 break;
3099 case 2:
3100 *secp = bfd_make_section_old_way (abfd, ".scommon_h");
3101 break;
3102 case 4:
3103 *secp = bfd_make_section_old_way (abfd, ".scommon_w");
3104 break;
3105 case 8:
3106 *secp = bfd_make_section_old_way (abfd, ".scommon_d");
3107 break;
3108 default:
3109 return TRUE;
3110 }
3111
3112 (*secp)->flags |= SEC_IS_COMMON;
3113 *valp = sym->st_size;
3114 break;
3115 }
3116
3117 return TRUE;
3118 }
3119
3120
3121 /* This function can figure out the best location for a base register to access
3122 data relative to this base register
3123 INPUT:
3124 sda_d0: size of first DOUBLE WORD data section
3125 sda_w0: size of first WORD data section
3126 sda_h0: size of first HALF WORD data section
3127 sda_b : size of BYTE data section
3128 sda_hi: size of second HALF WORD data section
3129 sda_w1: size of second WORD data section
3130 sda_d1: size of second DOUBLE WORD data section
3131 OUTPUT:
3132 offset (always positive) from the beginning of sda_d0 if OK
3133 a negative error value if fail
3134 NOTE:
3135 these 7 sections have to be located back to back if exist
3136 a pass in 0 value for non-existing section */
3137
3138 /* Due to the interpretation of simm15 field of load/store depending on
3139 data accessing size, the organization of base register relative data shall
3140 like the following figure
3141 -------------------------------------------
3142 | DOUBLE WORD sized data (range +/- 128K)
3143 -------------------------------------------
3144 | WORD sized data (range +/- 64K)
3145 -------------------------------------------
3146 | HALF WORD sized data (range +/- 32K)
3147 -------------------------------------------
3148 | BYTE sized data (range +/- 16K)
3149 -------------------------------------------
3150 | HALF WORD sized data (range +/- 32K)
3151 -------------------------------------------
3152 | WORD sized data (range +/- 64K)
3153 -------------------------------------------
3154 | DOUBLE WORD sized data (range +/- 128K)
3155 -------------------------------------------
3156 Its base register shall be set to access these data freely. */
3157
3158 /* We have to figure out the SDA_BASE value, so that we can adjust the
3159 symbol value correctly. We look up the symbol _SDA_BASE_ in the output
3160 BFD. If we can't find it, we're stuck. We cache it in the ELF
3161 target data. We don't need to adjust the symbol value for an
3162 external symbol if we are producing relocatable output. */
3163
3164 static asection *sda_rela_sec = NULL;
3165
3166 #define SDA_SECTION_NUM 10
3167
3168 static bfd_reloc_status_type
3169 nds32_elf_final_sda_base (bfd *output_bfd, struct bfd_link_info *info,
3170 bfd_vma *psb, bfd_boolean add_symbol)
3171 {
3172 int relax_fp_as_gp;
3173 struct elf_nds32_link_hash_table *table;
3174 struct bfd_link_hash_entry *h, *h2;
3175 long unsigned int total = 0;
3176
3177 h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
3178 if (!h || (h->type != bfd_link_hash_defined && h->type != bfd_link_hash_defweak))
3179 {
3180 asection *first = NULL, *final = NULL, *temp;
3181 bfd_vma sda_base;
3182 /* The first section must be 4-byte aligned to promise _SDA_BASE_ being
3183 4 byte-aligned. Therefore, it has to set the first section ".data"
3184 4 byte-aligned. */
3185 static const char sec_name[SDA_SECTION_NUM][10] =
3186 {
3187 ".data", ".got", ".sdata_d", ".sdata_w", ".sdata_h", ".sdata_b",
3188 ".sbss_b", ".sbss_h", ".sbss_w", ".sbss_d"
3189 };
3190 size_t i = 0;
3191
3192 if (output_bfd->sections == NULL)
3193 {
3194 *psb = elf_gp (output_bfd);
3195 return bfd_reloc_ok;
3196 }
3197
3198 /* Get the first and final section. */
3199 while (i < sizeof (sec_name) / sizeof (sec_name [0]))
3200 {
3201 temp = bfd_get_section_by_name (output_bfd, sec_name[i]);
3202 if (temp && !first && (temp->size != 0 || temp->rawsize != 0))
3203 first = temp;
3204 if (temp && (temp->size != 0 || temp->rawsize != 0))
3205 final = temp;
3206
3207 /* Summarize the sections in order to check if joining .bss. */
3208 if (temp && temp->size != 0)
3209 total += temp->size;
3210 else if (temp && temp->rawsize != 0)
3211 total += temp->rawsize;
3212
3213 i++;
3214 }
3215
3216 /* Check .bss size. */
3217 temp = bfd_get_section_by_name (output_bfd, ".bss");
3218 if (temp)
3219 {
3220 if (temp->size != 0)
3221 total += temp->size;
3222 else if (temp->rawsize != 0)
3223 total += temp->rawsize;
3224
3225 if (total < 0x80000)
3226 {
3227 if (!first && (temp->size != 0 || temp->rawsize != 0))
3228 first = temp;
3229 if ((temp->size != 0 || temp->rawsize != 0))
3230 final = temp;
3231 }
3232 }
3233
3234 if (first && final)
3235 {
3236 /* The middle of data region. */
3237 sda_base = final->vma / 2 + final->rawsize / 2 + first->vma / 2;
3238
3239 /* Find the section sda_base located. */
3240 i = 0;
3241 while (i < sizeof (sec_name) / sizeof (sec_name [0]))
3242 {
3243 final = bfd_get_section_by_name (output_bfd, sec_name[i]);
3244 if (final && (final->size != 0 || final->rawsize != 0)
3245 && sda_base >= final->vma)
3246 {
3247 first = final;
3248 i++;
3249 }
3250 else
3251 break;
3252 }
3253 }
3254 else
3255 {
3256 /* There is not any data section in output bfd, and set _SDA_BASE_ in
3257 first output section. */
3258 first = output_bfd->sections;
3259 while (first && first->size == 0 && first->rawsize == 0)
3260 first = first->next;
3261 if (!first)
3262 {
3263 *psb = elf_gp (output_bfd);
3264 return bfd_reloc_ok;
3265 }
3266 sda_base = first->vma + first->rawsize;
3267 }
3268
3269 sda_base -= first->vma;
3270 sda_base = sda_base & (~7);
3271
3272 if (!_bfd_generic_link_add_one_symbol
3273 (info, output_bfd, "_SDA_BASE_", BSF_GLOBAL | BSF_WEAK, first,
3274 (bfd_vma) sda_base, (const char *) NULL, FALSE,
3275 get_elf_backend_data (output_bfd)->collect, &h))
3276 return FALSE;
3277
3278 sda_rela_sec = first;
3279
3280 table = nds32_elf_hash_table (info);
3281 relax_fp_as_gp = table->relax_fp_as_gp;
3282 if (relax_fp_as_gp)
3283 {
3284 h2 = bfd_link_hash_lookup (info->hash, FP_BASE_NAME,
3285 FALSE, FALSE, FALSE);
3286 /* Define a weak FP_BASE_NAME here to prevent the undefined symbol.
3287 And set FP equal to SDA_BASE to do relaxation for
3288 la $fp, _FP_BASE_. */
3289 if (!_bfd_generic_link_add_one_symbol
3290 (info, output_bfd, FP_BASE_NAME, BSF_GLOBAL | BSF_WEAK,
3291 first, (bfd_vma) sda_base, (const char *) NULL,
3292 FALSE, get_elf_backend_data (output_bfd)->collect, &h2))
3293 return FALSE;
3294 }
3295 }
3296
3297 if (add_symbol == TRUE)
3298 {
3299 if (h)
3300 {
3301 /* Now set gp. */
3302 elf_gp (output_bfd) = (h->u.def.value
3303 + h->u.def.section->output_section->vma
3304 + h->u.def.section->output_offset);
3305 }
3306 else
3307 {
3308 _bfd_error_handler (_("error: Can't find symbol: _SDA_BASE_."));
3309 return bfd_reloc_dangerous;
3310 }
3311 }
3312
3313 *psb = h->u.def.value + h->u.def.section->output_section->vma
3314 + h->u.def.section->output_offset;
3315 return bfd_reloc_ok;
3316 }
3317 \f
3318
3319 /* Return size of a PLT entry. */
3320 #define elf_nds32_sizeof_plt(info) PLT_ENTRY_SIZE
3321
3322
3323 /* Create an entry in an nds32 ELF linker hash table. */
3324
3325 static struct bfd_hash_entry *
3326 nds32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
3327 struct bfd_hash_table *table,
3328 const char *string)
3329 {
3330 struct elf_nds32_link_hash_entry *ret;
3331
3332 ret = (struct elf_nds32_link_hash_entry *) entry;
3333
3334 /* Allocate the structure if it has not already been allocated by a
3335 subclass. */
3336 if (ret == NULL)
3337 ret = (struct elf_nds32_link_hash_entry *)
3338 bfd_hash_allocate (table, sizeof (struct elf_nds32_link_hash_entry));
3339
3340 if (ret == NULL)
3341 return (struct bfd_hash_entry *) ret;
3342
3343 /* Call the allocation method of the superclass. */
3344 ret = (struct elf_nds32_link_hash_entry *)
3345 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);
3346
3347 if (ret != NULL)
3348 {
3349 struct elf_nds32_link_hash_entry *eh;
3350
3351 eh = (struct elf_nds32_link_hash_entry *) ret;
3352 eh->dyn_relocs = NULL;
3353 eh->tls_type = GOT_UNKNOWN;
3354 }
3355
3356 return (struct bfd_hash_entry *) ret;
3357 }
3358
3359 /* Create an nds32 ELF linker hash table. */
3360
3361 static struct bfd_link_hash_table *
3362 nds32_elf_link_hash_table_create (bfd *abfd)
3363 {
3364 struct elf_nds32_link_hash_table *ret;
3365
3366 bfd_size_type amt = sizeof (struct elf_nds32_link_hash_table);
3367
3368 ret = (struct elf_nds32_link_hash_table *) bfd_zmalloc (amt);
3369 if (ret == NULL)
3370 return NULL;
3371
3372 /* patch tag. */
3373 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3374 nds32_elf_link_hash_newfunc,
3375 sizeof (struct elf_nds32_link_hash_entry),
3376 NDS32_ELF_DATA))
3377 {
3378 free (ret);
3379 return NULL;
3380 }
3381
3382 ret->sgot = NULL;
3383 ret->sgotplt = NULL;
3384 ret->srelgot = NULL;
3385 ret->splt = NULL;
3386 ret->srelplt = NULL;
3387 ret->sdynbss = NULL;
3388 ret->srelbss = NULL;
3389 ret->sym_ld_script = NULL;
3390 ret->ex9_export_file = NULL;
3391 ret->ex9_import_file = NULL;
3392
3393 return &ret->root.root;
3394 }
3395
3396 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
3397 shortcuts to them in our hash table. */
3398
3399 static bfd_boolean
3400 create_got_section (bfd *dynobj, struct bfd_link_info *info)
3401 {
3402 struct elf_nds32_link_hash_table *htab;
3403
3404 if (!_bfd_elf_create_got_section (dynobj, info))
3405 return FALSE;
3406
3407 htab = nds32_elf_hash_table (info);
3408 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
3409 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
3410 if (!htab->sgot || !htab->sgotplt)
3411 abort ();
3412
3413 /* _bfd_elf_create_got_section will create it for us. */
3414 htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3415 if (htab->srelgot == NULL
3416 || !bfd_set_section_flags (dynobj, htab->srelgot,
3417 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
3418 | SEC_IN_MEMORY | SEC_LINKER_CREATED
3419 | SEC_READONLY))
3420 || !bfd_set_section_alignment (dynobj, htab->srelgot, 2))
3421 return FALSE;
3422
3423 return TRUE;
3424 }
3425
3426 /* Create dynamic sections when linking against a dynamic object. */
3427
3428 static bfd_boolean
3429 nds32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3430 {
3431 struct elf_nds32_link_hash_table *htab;
3432 flagword flags, pltflags;
3433 register asection *s;
3434 const struct elf_backend_data *bed;
3435 int ptralign = 2; /* 32-bit */
3436
3437 bed = get_elf_backend_data (abfd);
3438
3439 htab = nds32_elf_hash_table (info);
3440
3441 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3442 .rel[a].bss sections. */
3443
3444 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3445 | SEC_LINKER_CREATED);
3446
3447 pltflags = flags;
3448 pltflags |= SEC_CODE;
3449 if (bed->plt_not_loaded)
3450 pltflags &= ~(SEC_LOAD | SEC_HAS_CONTENTS);
3451 if (bed->plt_readonly)
3452 pltflags |= SEC_READONLY;
3453
3454 s = bfd_make_section (abfd, ".plt");
3455 htab->splt = s;
3456 if (s == NULL
3457 || !bfd_set_section_flags (abfd, s, pltflags)
3458 || !bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3459 return FALSE;
3460
3461 if (bed->want_plt_sym)
3462 {
3463 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3464 .plt section. */
3465 struct bfd_link_hash_entry *bh = NULL;
3466 struct elf_link_hash_entry *h;
3467
3468 if (!(_bfd_generic_link_add_one_symbol
3469 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3470 (bfd_vma) 0, (const char *) NULL, FALSE,
3471 get_elf_backend_data (abfd)->collect, &bh)))
3472 return FALSE;
3473
3474 h = (struct elf_link_hash_entry *) bh;
3475 h->def_regular = 1;
3476 h->type = STT_OBJECT;
3477
3478 if (bfd_link_pic (info) && !bfd_elf_link_record_dynamic_symbol (info, h))
3479 return FALSE;
3480 }
3481
3482 s = bfd_make_section (abfd,
3483 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt");
3484 htab->srelplt = s;
3485 if (s == NULL
3486 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3487 || !bfd_set_section_alignment (abfd, s, ptralign))
3488 return FALSE;
3489
3490 if (htab->sgot == NULL && !create_got_section (abfd, info))
3491 return FALSE;
3492
3493 {
3494 const char *secname;
3495 char *relname;
3496 flagword secflags;
3497 asection *sec;
3498
3499 for (sec = abfd->sections; sec; sec = sec->next)
3500 {
3501 secflags = bfd_get_section_flags (abfd, sec);
3502 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3503 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3504 continue;
3505 secname = bfd_get_section_name (abfd, sec);
3506 relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
3507 strcpy (relname, ".rela");
3508 strcat (relname, secname);
3509 if (bfd_get_section_by_name (abfd, secname))
3510 continue;
3511 s = bfd_make_section (abfd, relname);
3512 if (s == NULL
3513 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3514 || !bfd_set_section_alignment (abfd, s, ptralign))
3515 return FALSE;
3516 }
3517 }
3518
3519 if (bed->want_dynbss)
3520 {
3521 /* The .dynbss section is a place to put symbols which are defined
3522 by dynamic objects, are referenced by regular objects, and are
3523 not functions. We must allocate space for them in the process
3524 image and use a R_*_COPY reloc to tell the dynamic linker to
3525 initialize them at run time. The linker script puts the .dynbss
3526 section into the .bss section of the final image. */
3527 s = bfd_make_section (abfd, ".dynbss");
3528 htab->sdynbss = s;
3529 if (s == NULL
3530 || !bfd_set_section_flags (abfd, s, SEC_ALLOC | SEC_LINKER_CREATED))
3531 return FALSE;
3532 /* The .rel[a].bss section holds copy relocs. This section is not
3533 normally needed. We need to create it here, though, so that the
3534 linker will map it to an output section. We can't just create it
3535 only if we need it, because we will not know whether we need it
3536 until we have seen all the input files, and the first time the
3537 main linker code calls BFD after examining all the input files
3538 (size_dynamic_sections) the input sections have already been
3539 mapped to the output sections. If the section turns out not to
3540 be needed, we can discard it later. We will never need this
3541 section when generating a shared object, since they do not use
3542 copy relocs. */
3543 if (!bfd_link_pic (info))
3544 {
3545 s = bfd_make_section (abfd, (bed->default_use_rela_p
3546 ? ".rela.bss" : ".rel.bss"));
3547 htab->srelbss = s;
3548 if (s == NULL
3549 || !bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3550 || !bfd_set_section_alignment (abfd, s, ptralign))
3551 return FALSE;
3552 }
3553 }
3554
3555 return TRUE;
3556 }
3557
3558 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3559 static void
3560 nds32_elf_copy_indirect_symbol (struct bfd_link_info *info,
3561 struct elf_link_hash_entry *dir,
3562 struct elf_link_hash_entry *ind)
3563 {
3564 struct elf_nds32_link_hash_entry *edir, *eind;
3565
3566 edir = (struct elf_nds32_link_hash_entry *) dir;
3567 eind = (struct elf_nds32_link_hash_entry *) ind;
3568
3569 if (eind->dyn_relocs != NULL)
3570 {
3571 if (edir->dyn_relocs != NULL)
3572 {
3573 struct elf_nds32_dyn_relocs **pp;
3574 struct elf_nds32_dyn_relocs *p;
3575
3576 if (ind->root.type == bfd_link_hash_indirect)
3577 abort ();
3578
3579 /* Add reloc counts against the weak sym to the strong sym
3580 list. Merge any entries against the same section. */
3581 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
3582 {
3583 struct elf_nds32_dyn_relocs *q;
3584
3585 for (q = edir->dyn_relocs; q != NULL; q = q->next)
3586 if (q->sec == p->sec)
3587 {
3588 q->pc_count += p->pc_count;
3589 q->count += p->count;
3590 *pp = p->next;
3591 break;
3592 }
3593 if (q == NULL)
3594 pp = &p->next;
3595 }
3596 *pp = edir->dyn_relocs;
3597 }
3598
3599 edir->dyn_relocs = eind->dyn_relocs;
3600 eind->dyn_relocs = NULL;
3601 }
3602
3603 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3604 }
3605 \f
3606
3607 /* Adjust a symbol defined by a dynamic object and referenced by a
3608 regular object. The current definition is in some section of the
3609 dynamic object, but we're not including those sections. We have to
3610 change the definition to something the rest of the link can
3611 understand. */
3612
3613 static bfd_boolean
3614 nds32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
3615 struct elf_link_hash_entry *h)
3616 {
3617 struct elf_nds32_link_hash_table *htab;
3618 struct elf_nds32_link_hash_entry *eh;
3619 struct elf_nds32_dyn_relocs *p;
3620 bfd *dynobj;
3621 asection *s;
3622 unsigned int power_of_two;
3623
3624 dynobj = elf_hash_table (info)->dynobj;
3625
3626 /* Make sure we know what is going on here. */
3627 BFD_ASSERT (dynobj != NULL
3628 && (h->needs_plt
3629 || h->u.weakdef != NULL
3630 || (h->def_dynamic && h->ref_regular && !h->def_regular)));
3631
3632
3633 /* If this is a function, put it in the procedure linkage table. We
3634 will fill in the contents of the procedure linkage table later,
3635 when we know the address of the .got section. */
3636 if (h->type == STT_FUNC || h->needs_plt)
3637 {
3638 if (!bfd_link_pic (info)
3639 && !h->def_dynamic
3640 && !h->ref_dynamic
3641 && h->root.type != bfd_link_hash_undefweak
3642 && h->root.type != bfd_link_hash_undefined)
3643 {
3644 /* This case can occur if we saw a PLT reloc in an input
3645 file, but the symbol was never referred to by a dynamic
3646 object. In such a case, we don't actually need to build
3647 a procedure linkage table, and we can just do a PCREL
3648 reloc instead. */
3649 h->plt.offset = (bfd_vma) - 1;
3650 h->needs_plt = 0;
3651 }
3652
3653 return TRUE;
3654 }
3655 else
3656 h->plt.offset = (bfd_vma) - 1;
3657
3658 /* If this is a weak symbol, and there is a real definition, the
3659 processor independent code will have arranged for us to see the
3660 real definition first, and we can just use the same value. */
3661 if (h->u.weakdef != NULL)
3662 {
3663 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3664 || h->u.weakdef->root.type == bfd_link_hash_defweak);
3665 h->root.u.def.section = h->u.weakdef->root.u.def.section;
3666 h->root.u.def.value = h->u.weakdef->root.u.def.value;
3667 return TRUE;
3668 }
3669
3670 /* This is a reference to a symbol defined by a dynamic object which
3671 is not a function. */
3672
3673 /* If we are creating a shared library, we must presume that the
3674 only references to the symbol are via the global offset table.
3675 For such cases we need not do anything here; the relocations will
3676 be handled correctly by relocate_section. */
3677 if (bfd_link_pic (info))
3678 return TRUE;
3679
3680 /* If there are no references to this symbol that do not use the
3681 GOT, we don't need to generate a copy reloc. */
3682 if (!h->non_got_ref)
3683 return TRUE;
3684
3685 /* If -z nocopyreloc was given, we won't generate them either. */
3686 if (info->nocopyreloc)
3687 {
3688 h->non_got_ref = 0;
3689 return TRUE;
3690 }
3691
3692 eh = (struct elf_nds32_link_hash_entry *) h;
3693 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3694 {
3695 s = p->sec->output_section;
3696 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
3697 break;
3698 }
3699
3700 /* If we didn't find any dynamic relocs in sections which needs the
3701 copy reloc, then we'll be keeping the dynamic relocs and avoiding
3702 the copy reloc. */
3703 if (p == NULL)
3704 {
3705 h->non_got_ref = 0;
3706 return TRUE;
3707 }
3708
3709 /* We must allocate the symbol in our .dynbss section, which will
3710 become part of the .bss section of the executable. There will be
3711 an entry for this symbol in the .dynsym section. The dynamic
3712 object will contain position independent code, so all references
3713 from the dynamic object to this symbol will go through the global
3714 offset table. The dynamic linker will use the .dynsym entry to
3715 determine the address it must put in the global offset table, so
3716 both the dynamic object and the regular object will refer to the
3717 same memory location for the variable. */
3718
3719 htab = nds32_elf_hash_table (info);
3720 s = htab->sdynbss;
3721 BFD_ASSERT (s != NULL);
3722
3723 /* We must generate a R_NDS32_COPY reloc to tell the dynamic linker
3724 to copy the initial value out of the dynamic object and into the
3725 runtime process image. We need to remember the offset into the
3726 .rela.bss section we are going to use. */
3727 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3728 {
3729 asection *srel;
3730
3731 srel = htab->srelbss;
3732 BFD_ASSERT (srel != NULL);
3733 srel->size += sizeof (Elf32_External_Rela);
3734 h->needs_copy = 1;
3735 }
3736
3737 /* We need to figure out the alignment required for this symbol. I
3738 have no idea how ELF linkers handle this. */
3739 power_of_two = bfd_log2 (h->size);
3740 if (power_of_two > 3)
3741 power_of_two = 3;
3742
3743 /* Apply the required alignment. */
3744 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
3745 if (power_of_two > bfd_get_section_alignment (dynobj, s))
3746 {
3747 if (!bfd_set_section_alignment (dynobj, s, power_of_two))
3748 return FALSE;
3749 }
3750
3751 /* Define the symbol as being at this point in the section. */
3752 h->root.u.def.section = s;
3753 h->root.u.def.value = s->size;
3754
3755 /* Increment the section size to make room for the symbol. */
3756 s->size += h->size;
3757
3758 return TRUE;
3759 }
3760
3761 /* Allocate space in .plt, .got and associated reloc sections for
3762 dynamic relocs. */
3763
3764 static bfd_boolean
3765 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3766 {
3767 struct bfd_link_info *info;
3768 struct elf_nds32_link_hash_table *htab;
3769 struct elf_nds32_link_hash_entry *eh;
3770 struct elf_nds32_dyn_relocs *p;
3771
3772 if (h->root.type == bfd_link_hash_indirect)
3773 return TRUE;
3774
3775 if (h->root.type == bfd_link_hash_warning)
3776 /* When warning symbols are created, they **replace** the "real"
3777 entry in the hash table, thus we never get to see the real
3778 symbol in a hash traversal. So look at it now. */
3779 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3780
3781 info = (struct bfd_link_info *) inf;
3782 htab = nds32_elf_hash_table (info);
3783
3784 eh = (struct elf_nds32_link_hash_entry *) h;
3785
3786 if (htab->root.dynamic_sections_created && h->plt.refcount > 0)
3787 {
3788 /* Make sure this symbol is output as a dynamic symbol.
3789 Undefined weak syms won't yet be marked as dynamic. */
3790 if (h->dynindx == -1 && !h->forced_local)
3791 {
3792 if (!bfd_elf_link_record_dynamic_symbol (info, h))
3793 return FALSE;
3794 }
3795
3796 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
3797 {
3798 asection *s = htab->splt;
3799
3800 /* If this is the first .plt entry, make room for the special
3801 first entry. */
3802 if (s->size == 0)
3803 s->size += PLT_ENTRY_SIZE;
3804
3805 h->plt.offset = s->size;
3806
3807 /* If this symbol is not defined in a regular file, and we are
3808 not generating a shared library, then set the symbol to this
3809 location in the .plt. This is required to make function
3810 pointers compare as equal between the normal executable and
3811 the shared library. */
3812 if (!bfd_link_pic (info) && !h->def_regular)
3813 {
3814 h->root.u.def.section = s;
3815 h->root.u.def.value = h->plt.offset;
3816 }
3817
3818 /* Make room for this entry. */
3819 s->size += PLT_ENTRY_SIZE;
3820
3821 /* We also need to make an entry in the .got.plt section, which
3822 will be placed in the .got section by the linker script. */
3823 htab->sgotplt->size += 4;
3824
3825 /* We also need to make an entry in the .rel.plt section. */
3826 htab->srelplt->size += sizeof (Elf32_External_Rela);
3827 }
3828 else
3829 {
3830 h->plt.offset = (bfd_vma) - 1;
3831 h->needs_plt = 0;
3832 }
3833 }
3834 else
3835 {
3836 h->plt.offset = (bfd_vma) - 1;
3837 h->needs_plt = 0;
3838 }
3839
3840 if (h->got.refcount > 0)
3841 {
3842 asection *s;
3843 bfd_boolean dyn;
3844 int tls_type = elf32_nds32_hash_entry (h)->tls_type;
3845
3846 /* Make sure this symbol is output as a dynamic symbol.
3847 Undefined weak syms won't yet be marked as dynamic. */
3848 if (h->dynindx == -1 && !h->forced_local)
3849 {
3850 if (!bfd_elf_link_record_dynamic_symbol (info, h))
3851 return FALSE;
3852 }
3853
3854 s = htab->sgot;
3855 h->got.offset = s->size;
3856
3857 if (tls_type == GOT_UNKNOWN)
3858 abort ();
3859 else if (tls_type == GOT_NORMAL
3860 || tls_type == GOT_TLS_IE)
3861 /* Need a GOT slot. */
3862 s->size += 4;
3863
3864 dyn = htab->root.dynamic_sections_created;
3865 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
3866 htab->srelgot->size += sizeof (Elf32_External_Rela);
3867 }
3868 else
3869 h->got.offset = (bfd_vma) - 1;
3870
3871 if (eh->dyn_relocs == NULL)
3872 return TRUE;
3873
3874 /* In the shared -Bsymbolic case, discard space allocated for
3875 dynamic pc-relative relocs against symbols which turn out to be
3876 defined in regular objects. For the normal shared case, discard
3877 space for pc-relative relocs that have become local due to symbol
3878 visibility changes. */
3879
3880 if (bfd_link_pic (info))
3881 {
3882 if (h->def_regular && (h->forced_local || info->symbolic))
3883 {
3884 struct elf_nds32_dyn_relocs **pp;
3885
3886 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
3887 {
3888 p->count -= p->pc_count;
3889 p->pc_count = 0;
3890 if (p->count == 0)
3891 *pp = p->next;
3892 else
3893 pp = &p->next;
3894 }
3895 }
3896 }
3897 else
3898 {
3899 /* For the non-shared case, discard space for relocs against
3900 symbols which turn out to need copy relocs or are not dynamic. */
3901
3902 if (!h->non_got_ref
3903 && ((h->def_dynamic
3904 && !h->def_regular)
3905 || (htab->root.dynamic_sections_created
3906 && (h->root.type == bfd_link_hash_undefweak
3907 || h->root.type == bfd_link_hash_undefined))))
3908 {
3909 /* Make sure this symbol is output as a dynamic symbol.
3910 Undefined weak syms won't yet be marked as dynamic. */
3911 if (h->dynindx == -1 && !h->forced_local)
3912 {
3913 if (!bfd_elf_link_record_dynamic_symbol (info, h))
3914 return FALSE;
3915 }
3916
3917 /* If that succeeded, we know we'll be keeping all the
3918 relocs. */
3919 if (h->dynindx != -1)
3920 goto keep;
3921 }
3922
3923 eh->dyn_relocs = NULL;
3924
3925 keep:;
3926 }
3927
3928 /* Finally, allocate space. */
3929 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3930 {
3931 asection *sreloc = elf_section_data (p->sec)->sreloc;
3932 sreloc->size += p->count * sizeof (Elf32_External_Rela);
3933 }
3934
3935 return TRUE;
3936 }
3937
3938 /* Find any dynamic relocs that apply to read-only sections. */
3939
3940 static bfd_boolean
3941 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3942 {
3943 struct elf_nds32_link_hash_entry *eh;
3944 struct elf_nds32_dyn_relocs *p;
3945
3946 if (h->root.type == bfd_link_hash_warning)
3947 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3948
3949 eh = (struct elf_nds32_link_hash_entry *) h;
3950 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3951 {
3952 asection *s = p->sec->output_section;
3953
3954 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3955 {
3956 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3957
3958 info->flags |= DF_TEXTREL;
3959
3960 /* Not an error, just cut short the traversal. */
3961 return FALSE;
3962 }
3963 }
3964 return TRUE;
3965 }
3966
3967 /* Set the sizes of the dynamic sections. */
3968
3969 static bfd_boolean
3970 nds32_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3971 struct bfd_link_info *info)
3972 {
3973 struct elf_nds32_link_hash_table *htab;
3974 bfd *dynobj;
3975 asection *s;
3976 bfd_boolean relocs;
3977 bfd *ibfd;
3978
3979 htab = nds32_elf_hash_table (info);
3980 dynobj = htab->root.dynobj;
3981 BFD_ASSERT (dynobj != NULL);
3982
3983 if (htab->root.dynamic_sections_created)
3984 {
3985 /* Set the contents of the .interp section to the interpreter. */
3986 if (!bfd_link_pic (info) && !info->nointerp)
3987 {
3988 s = bfd_get_section_by_name (dynobj, ".interp");
3989 BFD_ASSERT (s != NULL);
3990 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3991 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3992 }
3993 }
3994
3995 /* Set up .got offsets for local syms, and space for local dynamic
3996 relocs. */
3997 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3998 {
3999 bfd_signed_vma *local_got;
4000 bfd_signed_vma *end_local_got;
4001 bfd_size_type locsymcount;
4002 Elf_Internal_Shdr *symtab_hdr;
4003 asection *srel;
4004
4005 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
4006 continue;
4007
4008 for (s = ibfd->sections; s != NULL; s = s->next)
4009 {
4010 struct elf_nds32_dyn_relocs *p;
4011
4012 for (p = ((struct elf_nds32_dyn_relocs *)
4013 elf_section_data (s)->local_dynrel);
4014 p != NULL; p = p->next)
4015 {
4016 if (!bfd_is_abs_section (p->sec)
4017 && bfd_is_abs_section (p->sec->output_section))
4018 {
4019 /* Input section has been discarded, either because
4020 it is a copy of a linkonce section or due to
4021 linker script /DISCARD/, so we'll be discarding
4022 the relocs too. */
4023 }
4024 else if (p->count != 0)
4025 {
4026 srel = elf_section_data (p->sec)->sreloc;
4027 srel->size += p->count * sizeof (Elf32_External_Rela);
4028 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
4029 info->flags |= DF_TEXTREL;
4030 }
4031 }
4032 }
4033
4034 local_got = elf_local_got_refcounts (ibfd);
4035 if (!local_got)
4036 continue;
4037
4038 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4039 locsymcount = symtab_hdr->sh_info;
4040 end_local_got = local_got + locsymcount;
4041 s = htab->sgot;
4042 srel = htab->srelgot;
4043 for (; local_got < end_local_got; ++local_got)
4044 {
4045 if (*local_got > 0)
4046 {
4047 *local_got = s->size;
4048 s->size += 4;
4049 if (bfd_link_pic (info))
4050 srel->size += sizeof (Elf32_External_Rela);
4051 }
4052 else
4053 *local_got = (bfd_vma) - 1;
4054 }
4055 }
4056
4057 /* Allocate global sym .plt and .got entries, and space for global
4058 sym dynamic relocs. */
4059 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (void *) info);
4060
4061 /* We now have determined the sizes of the various dynamic sections.
4062 Allocate memory for them. */
4063 relocs = FALSE;
4064 for (s = dynobj->sections; s != NULL; s = s->next)
4065 {
4066 if ((s->flags & SEC_LINKER_CREATED) == 0)
4067 continue;
4068
4069 if (s == htab->splt)
4070 {
4071 /* Strip this section if we don't need it; see the
4072 comment below. */
4073 }
4074 else if (s == htab->sgot)
4075 {
4076 got_size += s->size;
4077 }
4078 else if (s == htab->sgotplt)
4079 {
4080 got_size += s->size;
4081 }
4082 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
4083 {
4084 if (s->size != 0 && s != htab->srelplt)
4085 relocs = TRUE;
4086
4087 /* We use the reloc_count field as a counter if we need
4088 to copy relocs into the output file. */
4089 s->reloc_count = 0;
4090 }
4091 else
4092 {
4093 /* It's not one of our sections, so don't allocate space. */
4094 continue;
4095 }
4096
4097 if (s->size == 0)
4098 {
4099 /* If we don't need this section, strip it from the
4100 output file. This is mostly to handle .rela.bss and
4101 .rela.plt. We must create both sections in
4102 create_dynamic_sections, because they must be created
4103 before the linker maps input sections to output
4104 sections. The linker does that before
4105 adjust_dynamic_symbol is called, and it is that
4106 function which decides whether anything needs to go
4107 into these sections. */
4108 s->flags |= SEC_EXCLUDE;
4109 continue;
4110 }
4111
4112 /* Allocate memory for the section contents. We use bfd_zalloc
4113 here in case unused entries are not reclaimed before the
4114 section's contents are written out. This should not happen,
4115 but this way if it does, we get a R_NDS32_NONE reloc instead
4116 of garbage. */
4117 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
4118 if (s->contents == NULL)
4119 return FALSE;
4120 }
4121
4122
4123 if (htab->root.dynamic_sections_created)
4124 {
4125 /* Add some entries to the .dynamic section. We fill in the
4126 values later, in nds32_elf_finish_dynamic_sections, but we
4127 must add the entries now so that we get the correct size for
4128 the .dynamic section. The DT_DEBUG entry is filled in by the
4129 dynamic linker and used by the debugger. */
4130 #define add_dynamic_entry(TAG, VAL) \
4131 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4132
4133 if (!bfd_link_pic (info))
4134 {
4135 if (!add_dynamic_entry (DT_DEBUG, 0))
4136 return FALSE;
4137 }
4138
4139 if (htab->splt->size != 0)
4140 {
4141 if (!add_dynamic_entry (DT_PLTGOT, 0)
4142 || !add_dynamic_entry (DT_PLTRELSZ, 0)
4143 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
4144 || !add_dynamic_entry (DT_JMPREL, 0))
4145 return FALSE;
4146 }
4147
4148 if (relocs)
4149 {
4150 if (!add_dynamic_entry (DT_RELA, 0)
4151 || !add_dynamic_entry (DT_RELASZ, 0)
4152 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
4153 return FALSE;
4154
4155 /* If any dynamic relocs apply to a read-only section,
4156 then we need a DT_TEXTREL entry. */
4157 if ((info->flags & DF_TEXTREL) == 0)
4158 elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
4159 (void *) info);
4160
4161 if ((info->flags & DF_TEXTREL) != 0)
4162 {
4163 if (!add_dynamic_entry (DT_TEXTREL, 0))
4164 return FALSE;
4165 }
4166 }
4167 }
4168 #undef add_dynamic_entry
4169
4170 return TRUE;
4171 }
4172
4173 static bfd_reloc_status_type
4174 nds32_relocate_contents (reloc_howto_type *howto, bfd *input_bfd,
4175 bfd_vma relocation, bfd_byte *location)
4176 {
4177 int size;
4178 bfd_vma x = 0;
4179 bfd_reloc_status_type flag;
4180 unsigned int rightshift = howto->rightshift;
4181 unsigned int bitpos = howto->bitpos;
4182
4183 /* If the size is negative, negate RELOCATION. This isn't very
4184 general. */
4185 if (howto->size < 0)
4186 relocation = -relocation;
4187
4188 /* Get the value we are going to relocate. */
4189 size = bfd_get_reloc_size (howto);
4190 switch (size)
4191 {
4192 default:
4193 abort ();
4194 break;
4195 case 0:
4196 return bfd_reloc_ok;
4197 case 2:
4198 x = bfd_getb16 (location);
4199 break;
4200 case 4:
4201 x = bfd_getb32 (location);
4202 break;
4203 }
4204
4205 /* Check for overflow. FIXME: We may drop bits during the addition
4206 which we don't check for. We must either check at every single
4207 operation, which would be tedious, or we must do the computations
4208 in a type larger than bfd_vma, which would be inefficient. */
4209 flag = bfd_reloc_ok;
4210 if (howto->complain_on_overflow != complain_overflow_dont)
4211 {
4212 bfd_vma addrmask, fieldmask, signmask, ss;
4213 bfd_vma a, b, sum;
4214
4215 /* Get the values to be added together. For signed and unsigned
4216 relocations, we assume that all values should be truncated to
4217 the size of an address. For bitfields, all the bits matter.
4218 See also bfd_check_overflow. */
4219 fieldmask = N_ONES (howto->bitsize);
4220 signmask = ~fieldmask;
4221 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
4222 a = (relocation & addrmask) >> rightshift;
4223 b = (x & howto->src_mask & addrmask) >> bitpos;
4224
4225 switch (howto->complain_on_overflow)
4226 {
4227 case complain_overflow_signed:
4228 /* If any sign bits are set, all sign bits must be set.
4229 That is, A must be a valid negative address after
4230 shifting. */
4231 signmask = ~(fieldmask >> 1);
4232 /* Fall through. */
4233
4234 case complain_overflow_bitfield:
4235 /* Much like the signed check, but for a field one bit
4236 wider. We allow a bitfield to represent numbers in the
4237 range -2**n to 2**n-1, where n is the number of bits in the
4238 field. Note that when bfd_vma is 32 bits, a 32-bit reloc
4239 can't overflow, which is exactly what we want. */
4240 ss = a & signmask;
4241 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
4242 flag = bfd_reloc_overflow;
4243
4244 /* We only need this next bit of code if the sign bit of B
4245 is below the sign bit of A. This would only happen if
4246 SRC_MASK had fewer bits than BITSIZE. Note that if
4247 SRC_MASK has more bits than BITSIZE, we can get into
4248 trouble; we would need to verify that B is in range, as
4249 we do for A above. */
4250 ss = ((~howto->src_mask) >> 1) & howto->src_mask;
4251 ss >>= bitpos;
4252
4253 /* Set all the bits above the sign bit. */
4254 b = (b ^ ss) - ss;
4255
4256 /* Now we can do the addition. */
4257 sum = a + b;
4258
4259 /* See if the result has the correct sign. Bits above the
4260 sign bit are junk now; ignore them. If the sum is
4261 positive, make sure we did not have all negative inputs;
4262 if the sum is negative, make sure we did not have all
4263 positive inputs. The test below looks only at the sign
4264 bits, and it really just
4265 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
4266
4267 We mask with addrmask here to explicitly allow an address
4268 wrap-around. The Linux kernel relies on it, and it is
4269 the only way to write assembler code which can run when
4270 loaded at a location 0x80000000 away from the location at
4271 which it is linked. */
4272 if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
4273 flag = bfd_reloc_overflow;
4274
4275 break;
4276
4277 case complain_overflow_unsigned:
4278 /* Checking for an unsigned overflow is relatively easy:
4279 trim the addresses and add, and trim the result as well.
4280 Overflow is normally indicated when the result does not
4281 fit in the field. However, we also need to consider the
4282 case when, e.g., fieldmask is 0x7fffffff or smaller, an
4283 input is 0x80000000, and bfd_vma is only 32 bits; then we
4284 will get sum == 0, but there is an overflow, since the
4285 inputs did not fit in the field. Instead of doing a
4286 separate test, we can check for this by or-ing in the
4287 operands when testing for the sum overflowing its final
4288 field. */
4289 sum = (a + b) & addrmask;
4290 if ((a | b | sum) & signmask)
4291 flag = bfd_reloc_overflow;
4292 break;
4293
4294 default:
4295 abort ();
4296 }
4297 }
4298
4299 /* Put RELOCATION in the right bits. */
4300 relocation >>= (bfd_vma) rightshift;
4301 relocation <<= (bfd_vma) bitpos;
4302
4303 /* Add RELOCATION to the right bits of X. */
4304 /* FIXME : 090616
4305 Because the relaxation may generate duplicate relocation at one address,
4306 an addition to immediate in the instruction may cause the relocation added
4307 several times.
4308 This bug should be fixed in assembler, but a check is also needed here. */
4309 if (howto->partial_inplace)
4310 x = ((x & ~howto->dst_mask)
4311 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
4312 else
4313 x = ((x & ~howto->dst_mask) | ((relocation) & howto->dst_mask));
4314
4315
4316 /* Put the relocated value back in the object file. */
4317 switch (size)
4318 {
4319 default:
4320 case 0:
4321 case 1:
4322 case 8:
4323 abort ();
4324 break;
4325 case 2:
4326 bfd_putb16 (x, location);
4327 break;
4328 case 4:
4329 bfd_putb32 (x, location);
4330 break;
4331 }
4332
4333 return flag;
4334 }
4335
4336 static bfd_reloc_status_type
4337 nds32_elf_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd,
4338 asection *input_section, bfd_byte *contents,
4339 bfd_vma address, bfd_vma value, bfd_vma addend)
4340 {
4341 bfd_vma relocation;
4342
4343 /* Sanity check the address. */
4344 if (address > bfd_get_section_limit (input_bfd, input_section))
4345 return bfd_reloc_outofrange;
4346
4347 /* This function assumes that we are dealing with a basic relocation
4348 against a symbol. We want to compute the value of the symbol to
4349 relocate to. This is just VALUE, the value of the symbol, plus
4350 ADDEND, any addend associated with the reloc. */
4351 relocation = value + addend;
4352
4353 /* If the relocation is PC relative, we want to set RELOCATION to
4354 the distance between the symbol (currently in RELOCATION) and the
4355 location we are relocating. Some targets (e.g., i386-aout)
4356 arrange for the contents of the section to be the negative of the
4357 offset of the location within the section; for such targets
4358 pcrel_offset is FALSE. Other targets (e.g., m88kbcs or ELF)
4359 simply leave the contents of the section as zero; for such
4360 targets pcrel_offset is TRUE. If pcrel_offset is FALSE we do not
4361 need to subtract out the offset of the location within the
4362 section (which is just ADDRESS). */
4363 if (howto->pc_relative)
4364 {
4365 relocation -= (input_section->output_section->vma
4366 + input_section->output_offset);
4367 if (howto->pcrel_offset)
4368 relocation -= address;
4369 }
4370
4371 return nds32_relocate_contents (howto, input_bfd, relocation,
4372 contents + address);
4373 }
4374
4375 static bfd_boolean
4376 nds32_elf_output_symbol_hook (struct bfd_link_info *info,
4377 const char *name,
4378 Elf_Internal_Sym *elfsym ATTRIBUTE_UNUSED,
4379 asection *input_sec,
4380 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4381 {
4382 const char *source;
4383 FILE *sym_ld_script = NULL;
4384 struct elf_nds32_link_hash_table *table;
4385
4386 table = nds32_elf_hash_table (info);
4387 sym_ld_script = table->sym_ld_script;
4388 if (!sym_ld_script)
4389 return TRUE;
4390
4391 if (!h || !name || *name == '\0')
4392 return TRUE;
4393
4394 if (input_sec->flags & SEC_EXCLUDE)
4395 return TRUE;
4396
4397 if (!check_start_export_sym)
4398 {
4399 fprintf (sym_ld_script, "SECTIONS\n{\n");
4400 check_start_export_sym = 1;
4401 }
4402
4403 if (h->root.type == bfd_link_hash_defined
4404 || h->root.type == bfd_link_hash_defweak)
4405 {
4406 if (!h->root.u.def.section->output_section)
4407 return TRUE;
4408
4409 if (bfd_is_const_section (input_sec))
4410 source = input_sec->name;
4411 else
4412 source = input_sec->owner->filename;
4413
4414 fprintf (sym_ld_script, "\t%s = 0x%08lx;\t /* %s */\n",
4415 h->root.root.string,
4416 (long) (h->root.u.def.value
4417 + h->root.u.def.section->output_section->vma
4418 + h->root.u.def.section->output_offset), source);
4419 }
4420
4421 return TRUE;
4422 }
4423
4424 /* Relocate an NDS32/D ELF section.
4425 There is some attempt to make this function usable for many architectures,
4426 both for RELA and REL type relocs, if only to serve as a learning tool.
4427
4428 The RELOCATE_SECTION function is called by the new ELF backend linker
4429 to handle the relocations for a section.
4430
4431 The relocs are always passed as Rela structures; if the section
4432 actually uses Rel structures, the r_addend field will always be
4433 zero.
4434
4435 This function is responsible for adjust the section contents as
4436 necessary, and (if using Rela relocs and generating a
4437 relocatable output file) adjusting the reloc addend as
4438 necessary.
4439
4440 This function does not have to worry about setting the reloc
4441 address or the reloc symbol index.
4442
4443 LOCAL_SYMS is a pointer to the swapped in local symbols.
4444
4445 LOCAL_SECTIONS is an array giving the section in the input file
4446 corresponding to the st_shndx field of each local symbol.
4447
4448 The global hash table entry for the global symbols can be found
4449 via elf_sym_hashes (input_bfd).
4450
4451 When generating relocatable output, this function must handle
4452 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
4453 going to be the section symbol corresponding to the output
4454 section, which means that the addend must be adjusted
4455 accordingly. */
4456
4457 static bfd_vma
4458 dtpoff_base (struct bfd_link_info *info)
4459 {
4460 /* If tls_sec is NULL, we should have signalled an error already. */
4461 if (elf_hash_table (info)->tls_sec == NULL)
4462 return 0;
4463 return elf_hash_table (info)->tls_sec->vma;
4464 }
4465
4466 static bfd_boolean
4467 nds32_elf_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
4468 struct bfd_link_info * info,
4469 bfd * input_bfd,
4470 asection * input_section,
4471 bfd_byte * contents,
4472 Elf_Internal_Rela * relocs,
4473 Elf_Internal_Sym * local_syms,
4474 asection ** local_sections)
4475 {
4476 Elf_Internal_Shdr *symtab_hdr;
4477 struct elf_link_hash_entry **sym_hashes;
4478 Elf_Internal_Rela *rel, *relend;
4479 bfd_boolean ret = TRUE; /* Assume success. */
4480 int align = 0;
4481 bfd_reloc_status_type r;
4482 const char *errmsg = NULL;
4483 bfd_vma gp;
4484 struct elf_nds32_link_hash_table *htab;
4485 bfd *dynobj;
4486 bfd_vma *local_got_offsets;
4487 asection *sgot, *splt, *sreloc;
4488 bfd_vma high_address;
4489 struct elf_nds32_link_hash_table *table;
4490 int eliminate_gc_relocs;
4491 bfd_vma fpbase_addr;
4492
4493 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4494 sym_hashes = elf_sym_hashes (input_bfd);
4495 htab = nds32_elf_hash_table (info);
4496 high_address = bfd_get_section_limit (input_bfd, input_section);
4497
4498 dynobj = htab->root.dynobj;
4499 local_got_offsets = elf_local_got_offsets (input_bfd);
4500
4501 sgot = htab->sgot;
4502 splt = htab->splt;
4503 sreloc = NULL;
4504
4505 rel = relocs;
4506 relend = relocs + input_section->reloc_count;
4507
4508 table = nds32_elf_hash_table (info);
4509 eliminate_gc_relocs = table->eliminate_gc_relocs;
4510 /* By this time, we can adjust the value of _SDA_BASE_. */
4511 if ((!bfd_link_relocatable (info)))
4512 {
4513 is_SDA_BASE_set = 1;
4514 r = nds32_elf_final_sda_base (output_bfd, info, &gp, TRUE);
4515 if (r != bfd_reloc_ok)
4516 return FALSE;
4517 }
4518
4519 if (is_ITB_BASE_set == 0)
4520 {
4521 /* Set the _ITB_BASE_. */
4522 if (!nds32_elf_ex9_itb_base (info))
4523 {
4524 _bfd_error_handler (_("%B: error: Cannot set _ITB_BASE_"),
4525 output_bfd);
4526 bfd_set_error (bfd_error_bad_value);
4527 }
4528 }
4529
4530 if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
4531 if (!nds32_elf_ifc_reloc ())
4532 _bfd_error_handler (_("error: IFC relocation error."));
4533
4534 /* Relocation for .ex9.itable. */
4535 if (table->target_optimize & NDS32_RELAX_EX9_ON
4536 || (table->ex9_import_file && table->update_ex9_table))
4537 nds32_elf_ex9_reloc_jmp (info);
4538
4539 /* Use gp as fp to prevent truncated fit. Because in relaxation time
4540 the fp value is set as gp, and it has be reverted for instruction
4541 setting fp. */
4542 fpbase_addr = elf_gp (output_bfd);
4543
4544 for (rel = relocs; rel < relend; rel++)
4545 {
4546 enum elf_nds32_reloc_type r_type;
4547 reloc_howto_type *howto = NULL;
4548 unsigned long r_symndx;
4549 struct elf_link_hash_entry *h = NULL;
4550 Elf_Internal_Sym *sym = NULL;
4551 asection *sec;
4552 bfd_vma relocation;
4553
4554 /* We can't modify r_addend here as elf_link_input_bfd has an assert to
4555 ensure it's zero (we use REL relocs, not RELA). Therefore this
4556 should be assigning zero to `addend', but for clarity we use
4557 `r_addend'. */
4558
4559 bfd_vma addend = rel->r_addend;
4560 bfd_vma offset = rel->r_offset;
4561
4562 r_type = ELF32_R_TYPE (rel->r_info);
4563 if (r_type >= R_NDS32_max)
4564 {
4565 _bfd_error_handler (_("%B: error: unknown relocation type %d."),
4566 input_bfd, r_type);
4567 bfd_set_error (bfd_error_bad_value);
4568 ret = FALSE;
4569 continue;
4570 }
4571
4572 if (r_type == R_NDS32_GNU_VTENTRY
4573 || r_type == R_NDS32_GNU_VTINHERIT
4574 || r_type == R_NDS32_NONE
4575 || r_type == R_NDS32_RELA_GNU_VTENTRY
4576 || r_type == R_NDS32_RELA_GNU_VTINHERIT
4577 || (r_type >= R_NDS32_INSN16 && r_type <= R_NDS32_25_FIXED_RELA)
4578 || r_type == R_NDS32_DATA
4579 || r_type == R_NDS32_TRAN
4580 || (r_type >= R_NDS32_LONGCALL4 && r_type <= R_NDS32_LONGJUMP7))
4581 continue;
4582
4583 /* If we enter the fp-as-gp region. Resolve the address
4584 of best fp-base. */
4585 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_BEGIN
4586 && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
4587 {
4588 int dist;
4589
4590 /* Distance to relocation of best fp-base is encoded in R_SYM. */
4591 dist = rel->r_addend >> 16;
4592 fpbase_addr = calculate_memory_address (input_bfd, rel + dist,
4593 local_syms, symtab_hdr);
4594 }
4595 else if (ELF32_R_TYPE (rel->r_info) == R_NDS32_RELAX_REGION_END
4596 && (rel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
4597 {
4598 fpbase_addr = elf_gp (output_bfd);
4599 }
4600
4601 if (((r_type >= R_NDS32_DWARF2_OP1_RELA
4602 && r_type <= R_NDS32_DWARF2_LEB_RELA)
4603 || r_type >= R_NDS32_RELAX_ENTRY) && !bfd_link_relocatable (info))
4604 continue;
4605
4606 howto = bfd_elf32_bfd_reloc_type_table_lookup (r_type);
4607 r_symndx = ELF32_R_SYM (rel->r_info);
4608
4609 /* This is a final link. */
4610 sym = NULL;
4611 sec = NULL;
4612 h = NULL;
4613
4614 if (r_symndx < symtab_hdr->sh_info)
4615 {
4616 /* Local symbol. */
4617 sym = local_syms + r_symndx;
4618 sec = local_sections[r_symndx];
4619
4620 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4621 addend = rel->r_addend;
4622 }
4623 else
4624 {
4625 /* External symbol. */
4626 bfd_boolean warned, ignored, unresolved_reloc;
4627 int symndx = r_symndx - symtab_hdr->sh_info;
4628
4629 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4630 r_symndx, symtab_hdr, sym_hashes, h, sec,
4631 relocation, unresolved_reloc, warned,
4632 ignored);
4633
4634 /* la $fp, _FP_BASE_ is per-function (region).
4635 Handle it specially. */
4636 switch ((int) r_type)
4637 {
4638 case R_NDS32_SDA19S0_RELA:
4639 case R_NDS32_SDA15S0_RELA:
4640 case R_NDS32_20_RELA:
4641 if (strcmp (elf_sym_hashes (input_bfd)[symndx]->root.root.string,
4642 FP_BASE_NAME) == 0)
4643 {
4644 relocation = fpbase_addr;
4645 break;
4646 }
4647 }
4648
4649 }
4650
4651 if (bfd_link_relocatable (info))
4652 {
4653 /* This is a relocatable link. We don't have to change
4654 anything, unless the reloc is against a section symbol,
4655 in which case we have to adjust according to where the
4656 section symbol winds up in the output section. */
4657 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4658 rel->r_addend += sec->output_offset + sym->st_value;
4659
4660 continue;
4661 }
4662
4663 /* Sanity check the address. */
4664 if (offset > high_address)
4665 {
4666 r = bfd_reloc_outofrange;
4667 goto check_reloc;
4668 }
4669
4670 if ((r_type >= R_NDS32_DWARF2_OP1_RELA
4671 && r_type <= R_NDS32_DWARF2_LEB_RELA)
4672 || r_type >= R_NDS32_RELAX_ENTRY)
4673 continue;
4674
4675 switch ((int) r_type)
4676 {
4677 case R_NDS32_GOTOFF:
4678 /* Relocation is relative to the start of the global offset
4679 table (for ld24 rx, #uimm24), e.g. access at label+addend
4680
4681 ld24 rx. #label@GOTOFF + addend
4682 sub rx, r12. */
4683 case R_NDS32_GOTOFF_HI20:
4684 case R_NDS32_GOTOFF_LO12:
4685 case R_NDS32_GOTOFF_LO15:
4686 case R_NDS32_GOTOFF_LO19:
4687 BFD_ASSERT (sgot != NULL);
4688
4689 relocation -= elf_gp (output_bfd);
4690 break;
4691
4692 case R_NDS32_9_PLTREL:
4693 case R_NDS32_25_PLTREL:
4694 /* Relocation is to the entry for this symbol in the
4695 procedure linkage table. */
4696
4697 /* The native assembler will generate a 25_PLTREL reloc
4698 for a local symbol if you assemble a call from one
4699 section to another when using -K pic. */
4700 if (h == NULL)
4701 break;
4702
4703 if (h->forced_local)
4704 break;
4705
4706 /* We didn't make a PLT entry for this symbol. This
4707 happens when statically linking PIC code, or when
4708 using -Bsymbolic. */
4709 if (h->plt.offset == (bfd_vma) - 1)
4710 break;
4711
4712 relocation = (splt->output_section->vma
4713 + splt->output_offset + h->plt.offset);
4714 break;
4715
4716 case R_NDS32_PLT_GOTREL_HI20:
4717 case R_NDS32_PLT_GOTREL_LO12:
4718 case R_NDS32_PLT_GOTREL_LO15:
4719 case R_NDS32_PLT_GOTREL_LO19:
4720 case R_NDS32_PLT_GOTREL_LO20:
4721 if (h == NULL || h->forced_local || h->plt.offset == (bfd_vma) - 1)
4722 {
4723 /* We didn't make a PLT entry for this symbol. This
4724 happens when statically linking PIC code, or when
4725 using -Bsymbolic. */
4726 relocation -= elf_gp (output_bfd);
4727 break;
4728 }
4729
4730 relocation = (splt->output_section->vma
4731 + splt->output_offset + h->plt.offset);
4732
4733 relocation -= elf_gp (output_bfd);
4734 break;
4735
4736 case R_NDS32_PLTREL_HI20:
4737 case R_NDS32_PLTREL_LO12:
4738
4739 /* Relocation is to the entry for this symbol in the
4740 procedure linkage table. */
4741
4742 /* The native assembler will generate a 25_PLTREL reloc
4743 for a local symbol if you assemble a call from one
4744 section to another when using -K pic. */
4745 if (h == NULL)
4746 break;
4747
4748 if (h->forced_local)
4749 break;
4750
4751 if (h->plt.offset == (bfd_vma) - 1)
4752 /* We didn't make a PLT entry for this symbol. This
4753 happens when statically linking PIC code, or when
4754 using -Bsymbolic. */
4755 break;
4756
4757 if (splt == NULL)
4758 break;
4759
4760 relocation = (splt->output_section->vma
4761 + splt->output_offset
4762 + h->plt.offset + 4)
4763 - (input_section->output_section->vma
4764 + input_section->output_offset
4765 + rel->r_offset);
4766
4767 break;
4768
4769 case R_NDS32_GOTPC20:
4770 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
4771 ld24 rx,#_GLOBAL_OFFSET_TABLE_ */
4772 relocation = elf_gp (output_bfd);
4773 break;
4774
4775 case R_NDS32_GOTPC_HI20:
4776 case R_NDS32_GOTPC_LO12:
4777 {
4778 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
4779 bl .+4
4780 seth rx,#high(_GLOBAL_OFFSET_TABLE_)
4781 or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
4782 or
4783 bl .+4
4784 seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
4785 add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
4786 */
4787 relocation = elf_gp (output_bfd);
4788 relocation -= (input_section->output_section->vma
4789 + input_section->output_offset + rel->r_offset);
4790 break;
4791 }
4792
4793 case R_NDS32_GOT20:
4794 /* Fall through. */
4795 case R_NDS32_GOT_HI20:
4796 case R_NDS32_GOT_LO12:
4797 case R_NDS32_GOT_LO15:
4798 case R_NDS32_GOT_LO19:
4799 /* Relocation is to the entry for this symbol in the global
4800 offset table. */
4801 BFD_ASSERT (sgot != NULL);
4802
4803 if (h != NULL)
4804 {
4805 bfd_boolean dyn;
4806 bfd_vma off;
4807
4808 off = h->got.offset;
4809 BFD_ASSERT (off != (bfd_vma) - 1);
4810 dyn = htab->root.dynamic_sections_created;
4811 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4812 bfd_link_pic (info),
4813 h)
4814 || (bfd_link_pic (info)
4815 && (info->symbolic
4816 || h->dynindx == -1
4817 || h->forced_local) && h->def_regular))
4818 {
4819 /* This is actually a static link, or it is a
4820 -Bsymbolic link and the symbol is defined
4821 locally, or the symbol was forced to be local
4822 because of a version file. We must initialize
4823 this entry in the global offset table. Since the
4824 offset must always be a multiple of 4, we use the
4825 least significant bit to record whether we have
4826 initialized it already.
4827
4828 When doing a dynamic link, we create a .rela.got
4829 relocation entry to initialize the value. This
4830 is done in the finish_dynamic_symbol routine. */
4831 if ((off & 1) != 0)
4832 off &= ~1;
4833 else
4834 {
4835 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
4836 h->got.offset |= 1;
4837 }
4838 }
4839 relocation = sgot->output_section->vma + sgot->output_offset + off
4840 - elf_gp (output_bfd);
4841 }
4842 else
4843 {
4844 bfd_vma off;
4845 bfd_byte *loc;
4846
4847 BFD_ASSERT (local_got_offsets != NULL
4848 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
4849
4850 off = local_got_offsets[r_symndx];
4851
4852 /* The offset must always be a multiple of 4. We use
4853 the least significant bit to record whether we have
4854 already processed this entry. */
4855 if ((off & 1) != 0)
4856 off &= ~1;
4857 else
4858 {
4859 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
4860
4861 if (bfd_link_pic (info))
4862 {
4863 asection *srelgot;
4864 Elf_Internal_Rela outrel;
4865
4866 /* We need to generate a R_NDS32_RELATIVE reloc
4867 for the dynamic linker. */
4868 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
4869 BFD_ASSERT (srelgot != NULL);
4870
4871 outrel.r_offset = (elf_gp (output_bfd)
4872 + sgot->output_offset + off);
4873 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
4874 outrel.r_addend = relocation;
4875 loc = srelgot->contents;
4876 loc +=
4877 srelgot->reloc_count * sizeof (Elf32_External_Rela);
4878 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4879 ++srelgot->reloc_count;
4880 }
4881 local_got_offsets[r_symndx] |= 1;
4882 }
4883 relocation = sgot->output_section->vma + sgot->output_offset + off
4884 - elf_gp (output_bfd);
4885 }
4886
4887 break;
4888
4889 case R_NDS32_16_RELA:
4890 case R_NDS32_20_RELA:
4891 case R_NDS32_5_RELA:
4892 case R_NDS32_32_RELA:
4893 case R_NDS32_9_PCREL_RELA:
4894 case R_NDS32_WORD_9_PCREL_RELA:
4895 case R_NDS32_10_UPCREL_RELA:
4896 case R_NDS32_15_PCREL_RELA:
4897 case R_NDS32_17_PCREL_RELA:
4898 case R_NDS32_25_PCREL_RELA:
4899 case R_NDS32_HI20_RELA:
4900 case R_NDS32_LO12S3_RELA:
4901 case R_NDS32_LO12S2_RELA:
4902 case R_NDS32_LO12S2_DP_RELA:
4903 case R_NDS32_LO12S2_SP_RELA:
4904 case R_NDS32_LO12S1_RELA:
4905 case R_NDS32_LO12S0_RELA:
4906 case R_NDS32_LO12S0_ORI_RELA:
4907 if (bfd_link_pic (info) && r_symndx != 0
4908 && (input_section->flags & SEC_ALLOC) != 0
4909 && (eliminate_gc_relocs == 0
4910 || (sec && (sec->flags & SEC_EXCLUDE) == 0))
4911 && ((r_type != R_NDS32_9_PCREL_RELA
4912 && r_type != R_NDS32_WORD_9_PCREL_RELA
4913 && r_type != R_NDS32_10_UPCREL_RELA
4914 && r_type != R_NDS32_15_PCREL_RELA
4915 && r_type != R_NDS32_17_PCREL_RELA
4916 && r_type != R_NDS32_25_PCREL_RELA
4917 && !(r_type == R_NDS32_32_RELA
4918 && strcmp (input_section->name, ".eh_frame") == 0))
4919 || (h != NULL && h->dynindx != -1
4920 && (!info->symbolic || !h->def_regular))))
4921 {
4922 Elf_Internal_Rela outrel;
4923 bfd_boolean skip, relocate;
4924 bfd_byte *loc;
4925
4926 /* When generating a shared object, these relocations
4927 are copied into the output file to be resolved at run
4928 time. */
4929
4930 if (sreloc == NULL)
4931 {
4932 const char *name;
4933
4934 name = bfd_elf_string_from_elf_section
4935 (input_bfd, elf_elfheader (input_bfd)->e_shstrndx,
4936 elf_section_data (input_section)->rela.hdr->sh_name);
4937 if (name == NULL)
4938 return FALSE;
4939
4940 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
4941 && strcmp (bfd_get_section_name (input_bfd,
4942 input_section),
4943 name + 5) == 0);
4944
4945 sreloc = bfd_get_section_by_name (dynobj, name);
4946 BFD_ASSERT (sreloc != NULL);
4947 }
4948
4949 skip = FALSE;
4950 relocate = FALSE;
4951
4952 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
4953 info,
4954 input_section,
4955 rel->r_offset);
4956 if (outrel.r_offset == (bfd_vma) - 1)
4957 skip = TRUE;
4958 else if (outrel.r_offset == (bfd_vma) - 2)
4959 skip = TRUE, relocate = TRUE;
4960 outrel.r_offset += (input_section->output_section->vma
4961 + input_section->output_offset);
4962
4963 if (skip)
4964 memset (&outrel, 0, sizeof outrel);
4965 else if (r_type == R_NDS32_17_PCREL_RELA
4966 || r_type == R_NDS32_15_PCREL_RELA
4967 || r_type == R_NDS32_25_PCREL_RELA)
4968 {
4969 BFD_ASSERT (h != NULL && h->dynindx != -1);
4970 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4971 outrel.r_addend = rel->r_addend;
4972 }
4973 else
4974 {
4975 /* h->dynindx may be -1 if this symbol was marked to
4976 become local. */
4977 if (h == NULL
4978 || ((info->symbolic || h->dynindx == -1)
4979 && h->def_regular))
4980 {
4981 relocate = TRUE;
4982 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
4983 outrel.r_addend = relocation + rel->r_addend;
4984 }
4985 else
4986 {
4987 BFD_ASSERT (h->dynindx != -1);
4988 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4989 outrel.r_addend = rel->r_addend;
4990 }
4991 }
4992
4993 loc = sreloc->contents;
4994 loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
4995 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4996 ++sreloc->reloc_count;
4997
4998 /* If this reloc is against an external symbol, we do
4999 not want to fiddle with the addend. Otherwise, we
5000 need to include the symbol value so that it becomes
5001 an addend for the dynamic reloc. */
5002 if (!relocate)
5003 continue;
5004 }
5005 break;
5006
5007 case R_NDS32_25_ABS_RELA:
5008 if (bfd_link_pic (info))
5009 {
5010 _bfd_error_handler
5011 (_("%s: warning: cannot deal R_NDS32_25_ABS_RELA in shared "
5012 "mode."), bfd_get_filename (input_bfd));
5013 return FALSE;
5014 }
5015 break;
5016
5017 case R_NDS32_9_PCREL:
5018 r = nds32_elf_do_9_pcrel_reloc (input_bfd, howto, input_section,
5019 contents, offset,
5020 sec, relocation, addend);
5021 goto check_reloc;
5022
5023 case R_NDS32_HI20:
5024 {
5025 Elf_Internal_Rela *lorel;
5026
5027 /* We allow an arbitrary number of HI20 relocs before the
5028 LO12 reloc. This permits gcc to emit the HI and LO relocs
5029 itself. */
5030 for (lorel = rel + 1;
5031 (lorel < relend
5032 && ELF32_R_TYPE (lorel->r_info) == R_NDS32_HI20); lorel++)
5033 continue;
5034 if (lorel < relend
5035 && (ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S3
5036 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S2
5037 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S1
5038 || ELF32_R_TYPE (lorel->r_info) == R_NDS32_LO12S0))
5039 {
5040 nds32_elf_relocate_hi20 (input_bfd, r_type, rel, lorel,
5041 contents, relocation + addend);
5042 r = bfd_reloc_ok;
5043 }
5044 else
5045 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5046 contents, offset, relocation,
5047 addend);
5048 }
5049
5050 goto check_reloc;
5051
5052 case R_NDS32_GOT17S2_RELA:
5053 case R_NDS32_GOT15S2_RELA:
5054 {
5055 bfd_vma off;
5056
5057 BFD_ASSERT (sgot != NULL);
5058
5059 if (h != NULL)
5060 {
5061 bfd_boolean dyn;
5062
5063 off = h->got.offset;
5064 BFD_ASSERT (off != (bfd_vma) - 1);
5065
5066 dyn = htab->root.dynamic_sections_created;
5067 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL
5068 (dyn, bfd_link_pic (info), h)
5069 || (bfd_link_pic (info)
5070 && (info->symbolic
5071 || h->dynindx == -1
5072 || h->forced_local)
5073 && h->def_regular))
5074 {
5075 /* This is actually a static link, or it is a
5076 -Bsymbolic link and the symbol is defined
5077 locally, or the symbol was forced to be local
5078 because of a version file. We must initialize
5079 this entry in the global offset table. Since the
5080 offset must always be a multiple of 4, we use the
5081 least significant bit to record whether we have
5082 initialized it already.
5083
5084 When doing a dynamic link, we create a .rela.got
5085 relocation entry to initialize the value. This
5086 is done in the finish_dynamic_symbol routine. */
5087 if ((off & 1) != 0)
5088 off &= ~1;
5089 else
5090 {
5091 bfd_put_32 (output_bfd, relocation,
5092 sgot->contents + off);
5093 h->got.offset |= 1;
5094 }
5095 }
5096 }
5097 else
5098 {
5099 bfd_byte *loc;
5100
5101 BFD_ASSERT (local_got_offsets != NULL
5102 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5103
5104 off = local_got_offsets[r_symndx];
5105
5106 /* The offset must always be a multiple of 4. We use
5107 the least significant bit to record whether we have
5108 already processed this entry. */
5109 if ((off & 1) != 0)
5110 off &= ~1;
5111 else
5112 {
5113 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5114
5115 if (bfd_link_pic (info))
5116 {
5117 asection *srelgot;
5118 Elf_Internal_Rela outrel;
5119
5120 /* We need to generate a R_NDS32_RELATIVE reloc
5121 for the dynamic linker. */
5122 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5123 BFD_ASSERT (srelgot != NULL);
5124
5125 outrel.r_offset = (elf_gp (output_bfd)
5126 + sgot->output_offset + off);
5127 outrel.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5128 outrel.r_addend = relocation;
5129 loc = srelgot->contents;
5130 loc +=
5131 srelgot->reloc_count * sizeof (Elf32_External_Rela);
5132 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5133 ++srelgot->reloc_count;
5134 }
5135 local_got_offsets[r_symndx] |= 1;
5136 }
5137 }
5138 relocation = sgot->output_section->vma + sgot->output_offset + off
5139 - elf_gp (output_bfd);
5140 }
5141 if (relocation & align)
5142 {
5143 /* Incorrect alignment. */
5144 _bfd_error_handler
5145 (_("%B: warning: unaligned access to GOT entry."), input_bfd);
5146 ret = FALSE;
5147 r = bfd_reloc_dangerous;
5148 goto check_reloc;
5149 }
5150 break;
5151
5152 case R_NDS32_SDA16S3_RELA:
5153 case R_NDS32_SDA15S3_RELA:
5154 case R_NDS32_SDA15S3:
5155 align = 0x7;
5156 goto handle_sda;
5157
5158 case R_NDS32_SDA17S2_RELA:
5159 case R_NDS32_SDA15S2_RELA:
5160 case R_NDS32_SDA12S2_SP_RELA:
5161 case R_NDS32_SDA12S2_DP_RELA:
5162 case R_NDS32_SDA15S2:
5163 case R_NDS32_SDA_FP7U2_RELA:
5164 align = 0x3;
5165 goto handle_sda;
5166
5167 case R_NDS32_SDA18S1_RELA:
5168 case R_NDS32_SDA15S1_RELA:
5169 case R_NDS32_SDA15S1:
5170 align = 0x1;
5171 goto handle_sda;
5172
5173 case R_NDS32_SDA19S0_RELA:
5174 case R_NDS32_SDA15S0_RELA:
5175 case R_NDS32_SDA15S0:
5176 {
5177 align = 0x0;
5178 handle_sda:
5179 BFD_ASSERT (sec != NULL);
5180
5181 /* If the symbol is in the abs section, the out_bfd will be null.
5182 This happens when the relocation has a symbol@GOTOFF. */
5183 r = nds32_elf_final_sda_base (output_bfd, info, &gp, FALSE);
5184 if (r != bfd_reloc_ok)
5185 {
5186 _bfd_error_handler
5187 (_("%B: warning: relocate SDA_BASE failed."), input_bfd);
5188 ret = FALSE;
5189 goto check_reloc;
5190 }
5191
5192 /* At this point `relocation' contains the object's
5193 address. */
5194 if (r_type == R_NDS32_SDA_FP7U2_RELA)
5195 {
5196 relocation -= fpbase_addr;
5197 }
5198 else
5199 relocation -= gp;
5200 /* Now it contains the offset from _SDA_BASE_. */
5201
5202 /* Make sure alignment is correct. */
5203
5204 if (relocation & align)
5205 {
5206 /* Incorrect alignment. */
5207 _bfd_error_handler
5208 (_("%B(%A): warning: unaligned small data access of type %d."),
5209 input_bfd, input_section, r_type);
5210 ret = FALSE;
5211 goto check_reloc;
5212 }
5213 }
5214
5215 break;
5216 case R_NDS32_17IFC_PCREL_RELA:
5217 case R_NDS32_10IFCU_PCREL_RELA:
5218 /* do nothing */
5219 break;
5220
5221 case R_NDS32_TLS_LE_HI20:
5222 case R_NDS32_TLS_LE_LO12:
5223 case R_NDS32_TLS_LE_20:
5224 case R_NDS32_TLS_LE_15S0:
5225 case R_NDS32_TLS_LE_15S1:
5226 case R_NDS32_TLS_LE_15S2:
5227 if (elf_hash_table (info)->tls_sec != NULL)
5228 relocation -= (elf_hash_table (info)->tls_sec->vma + TP_OFFSET);
5229 break;
5230 case R_NDS32_TLS_IE_HI20:
5231 case R_NDS32_TLS_IE_LO12S2:
5232 {
5233 /* Relocation is to the entry for this symbol in the global
5234 offset table. */
5235 unsigned int tls_type;
5236 asection *srelgot;
5237 Elf_Internal_Rela outrel;
5238 bfd_vma off;
5239 bfd_byte *loc;
5240 int indx = 0;
5241
5242 BFD_ASSERT (sgot != NULL);
5243 if (h != NULL)
5244 {
5245 bfd_boolean dyn;
5246
5247 off = h->got.offset;
5248 BFD_ASSERT (off != (bfd_vma) - 1);
5249 dyn = htab->root.dynamic_sections_created;
5250 tls_type = ((struct elf_nds32_link_hash_entry *) h)->tls_type;
5251 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
5252 && (!bfd_link_pic (info)
5253 || !SYMBOL_REFERENCES_LOCAL (info, h)))
5254 indx = h->dynindx;
5255 }
5256 else
5257 {
5258 /* Never happen currently. */
5259 BFD_ASSERT (local_got_offsets != NULL
5260 && local_got_offsets[r_symndx] != (bfd_vma) - 1);
5261
5262 off = local_got_offsets[r_symndx];
5263
5264 tls_type = elf32_nds32_local_got_tls_type (input_bfd)[r_symndx];
5265 }
5266 relocation = sgot->output_section->vma + sgot->output_offset + off;
5267
5268 if (r_type == R_NDS32_TLS_IE_LO12S2)
5269 break;
5270
5271 /* The offset must always be a multiple of 4. We use
5272 the least significant bit to record whether we have
5273 already processed this entry. */
5274 if ((off & 1) != 0)
5275 off &= ~1;
5276 else
5277 {
5278 bfd_boolean need_relocs = FALSE;
5279 srelgot = htab->srelgot;
5280 if ((bfd_link_pic (info) || indx != 0)
5281 && (h == NULL
5282 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5283 || h->root.type != bfd_link_hash_undefweak))
5284 {
5285 need_relocs = TRUE;
5286 BFD_ASSERT (srelgot != NULL);
5287 }
5288 if (tls_type & GOT_TLS_IE)
5289 {
5290 if (need_relocs)
5291 {
5292 if (h->dynindx == 0)
5293 outrel.r_addend = relocation - dtpoff_base (info);
5294 else
5295 outrel.r_addend = 0;
5296 outrel.r_offset = (sgot->output_section->vma
5297 + sgot->output_offset
5298 + off);
5299 outrel.r_info =
5300 ELF32_R_INFO (h->dynindx, R_NDS32_TLS_TPOFF);
5301
5302 loc = srelgot->contents;
5303 loc +=
5304 srelgot->reloc_count * sizeof (Elf32_External_Rela);
5305 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5306 ++srelgot->reloc_count;
5307 }
5308 else
5309 bfd_put_32 (output_bfd, h->root.u.def.value - TP_OFFSET,
5310 sgot->contents + off);
5311 }
5312 }
5313 }
5314 break;
5315
5316 /* DON'T fall through. */
5317
5318 default:
5319 /* OLD_NDS32_RELOC. */
5320
5321 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5322 contents, offset, relocation, addend);
5323 goto check_reloc;
5324 }
5325
5326 switch ((int) r_type)
5327 {
5328 case R_NDS32_20_RELA:
5329 case R_NDS32_5_RELA:
5330 case R_NDS32_9_PCREL_RELA:
5331 case R_NDS32_WORD_9_PCREL_RELA:
5332 case R_NDS32_10_UPCREL_RELA:
5333 case R_NDS32_15_PCREL_RELA:
5334 case R_NDS32_17_PCREL_RELA:
5335 case R_NDS32_25_PCREL_RELA:
5336 case R_NDS32_25_ABS_RELA:
5337 case R_NDS32_HI20_RELA:
5338 case R_NDS32_LO12S3_RELA:
5339 case R_NDS32_LO12S2_RELA:
5340 case R_NDS32_LO12S2_DP_RELA:
5341 case R_NDS32_LO12S2_SP_RELA:
5342 case R_NDS32_LO12S1_RELA:
5343 case R_NDS32_LO12S0_RELA:
5344 case R_NDS32_LO12S0_ORI_RELA:
5345 case R_NDS32_SDA16S3_RELA:
5346 case R_NDS32_SDA17S2_RELA:
5347 case R_NDS32_SDA18S1_RELA:
5348 case R_NDS32_SDA19S0_RELA:
5349 case R_NDS32_SDA15S3_RELA:
5350 case R_NDS32_SDA15S2_RELA:
5351 case R_NDS32_SDA12S2_DP_RELA:
5352 case R_NDS32_SDA12S2_SP_RELA:
5353 case R_NDS32_SDA15S1_RELA:
5354 case R_NDS32_SDA15S0_RELA:
5355 case R_NDS32_SDA_FP7U2_RELA:
5356 case R_NDS32_9_PLTREL:
5357 case R_NDS32_25_PLTREL:
5358 case R_NDS32_GOT20:
5359 case R_NDS32_GOT_HI20:
5360 case R_NDS32_GOT_LO12:
5361 case R_NDS32_GOT_LO15:
5362 case R_NDS32_GOT_LO19:
5363 case R_NDS32_GOT15S2_RELA:
5364 case R_NDS32_GOT17S2_RELA:
5365 case R_NDS32_GOTPC20:
5366 case R_NDS32_GOTPC_HI20:
5367 case R_NDS32_GOTPC_LO12:
5368 case R_NDS32_GOTOFF:
5369 case R_NDS32_GOTOFF_HI20:
5370 case R_NDS32_GOTOFF_LO12:
5371 case R_NDS32_GOTOFF_LO15:
5372 case R_NDS32_GOTOFF_LO19:
5373 case R_NDS32_PLTREL_HI20:
5374 case R_NDS32_PLTREL_LO12:
5375 case R_NDS32_PLT_GOTREL_HI20:
5376 case R_NDS32_PLT_GOTREL_LO12:
5377 case R_NDS32_PLT_GOTREL_LO15:
5378 case R_NDS32_PLT_GOTREL_LO19:
5379 case R_NDS32_PLT_GOTREL_LO20:
5380 case R_NDS32_17IFC_PCREL_RELA:
5381 case R_NDS32_10IFCU_PCREL_RELA:
5382 case R_NDS32_TLS_LE_HI20:
5383 case R_NDS32_TLS_LE_LO12:
5384 case R_NDS32_TLS_IE_HI20:
5385 case R_NDS32_TLS_IE_LO12S2:
5386 case R_NDS32_TLS_LE_20:
5387 case R_NDS32_TLS_LE_15S0:
5388 case R_NDS32_TLS_LE_15S1:
5389 case R_NDS32_TLS_LE_15S2:
5390 /* Instruction related relocs must handle endian properly. */
5391 /* NOTE: PIC IS NOT HANDLE YET; DO IT LATER. */
5392 r = nds32_elf_final_link_relocate (howto, input_bfd,
5393 input_section, contents,
5394 rel->r_offset, relocation,
5395 rel->r_addend);
5396 break;
5397
5398 default:
5399 /* All other relocs can use default handler. */
5400 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5401 contents, rel->r_offset,
5402 relocation, rel->r_addend);
5403 break;
5404 }
5405
5406 check_reloc:
5407
5408 if (r != bfd_reloc_ok)
5409 {
5410 /* FIXME: This should be generic enough to go in a utility. */
5411 const char *name;
5412
5413 if (h != NULL)
5414 name = h->root.root.string;
5415 else
5416 {
5417 name = bfd_elf_string_from_elf_section
5418 (input_bfd, symtab_hdr->sh_link, sym->st_name);
5419 if (name == NULL || *name == '\0')
5420 name = bfd_section_name (input_bfd, sec);
5421 }
5422
5423 if (errmsg != NULL)
5424 goto common_error;
5425
5426 switch (r)
5427 {
5428 case bfd_reloc_overflow:
5429 (*info->callbacks->reloc_overflow)
5430 (info, (h ? &h->root : NULL), name, howto->name,
5431 (bfd_vma) 0, input_bfd, input_section, offset);
5432 break;
5433
5434 case bfd_reloc_undefined:
5435 (*info->callbacks->undefined_symbol)
5436 (info, name, input_bfd, input_section, offset, TRUE);
5437 break;
5438
5439 case bfd_reloc_outofrange:
5440 errmsg = _("internal error: out of range error");
5441 goto common_error;
5442
5443 case bfd_reloc_notsupported:
5444 errmsg = _("internal error: unsupported relocation error");
5445 goto common_error;
5446
5447 case bfd_reloc_dangerous:
5448 errmsg = _("internal error: dangerous error");
5449 goto common_error;
5450
5451 default:
5452 errmsg = _("internal error: unknown error");
5453 /* Fall through. */
5454
5455 common_error:
5456 (*info->callbacks->warning) (info, errmsg, name, input_bfd,
5457 input_section, offset);
5458 break;
5459 }
5460 }
5461 }
5462
5463 return ret;
5464 }
5465
5466 /* Finish up dynamic symbol handling. We set the contents of various
5467 dynamic sections here. */
5468
5469 static bfd_boolean
5470 nds32_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
5471 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)
5472 {
5473 struct elf_nds32_link_hash_table *htab;
5474 bfd_byte *loc;
5475
5476 htab = nds32_elf_hash_table (info);
5477
5478 if (h->plt.offset != (bfd_vma) - 1)
5479 {
5480 asection *splt;
5481 asection *sgot;
5482 asection *srela;
5483
5484 bfd_vma plt_index;
5485 bfd_vma got_offset;
5486 bfd_vma local_plt_offset;
5487 Elf_Internal_Rela rela;
5488
5489 /* This symbol has an entry in the procedure linkage table. Set
5490 it up. */
5491
5492 BFD_ASSERT (h->dynindx != -1);
5493
5494 splt = htab->splt;
5495 sgot = htab->sgotplt;
5496 srela = htab->srelplt;
5497 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
5498
5499 /* Get the index in the procedure linkage table which
5500 corresponds to this symbol. This is the index of this symbol
5501 in all the symbols for which we are making plt entries. The
5502 first entry in the procedure linkage table is reserved. */
5503 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
5504
5505 /* Get the offset into the .got table of the entry that
5506 corresponds to this function. Each .got entry is 4 bytes.
5507 The first three are reserved. */
5508 got_offset = (plt_index + 3) * 4;
5509
5510 /* Fill in the entry in the procedure linkage table. */
5511 if (!bfd_link_pic (info))
5512 {
5513 unsigned long insn;
5514
5515 insn = PLT_ENTRY_WORD0 + (((sgot->output_section->vma
5516 + sgot->output_offset + got_offset) >> 12)
5517 & 0xfffff);
5518 bfd_putb32 (insn, splt->contents + h->plt.offset);
5519
5520 insn = PLT_ENTRY_WORD1 + (((sgot->output_section->vma
5521 + sgot->output_offset + got_offset) & 0x0fff)
5522 >> 2);
5523 bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
5524
5525 insn = PLT_ENTRY_WORD2;
5526 bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
5527
5528 insn = PLT_ENTRY_WORD3 + (plt_index & 0x7ffff);
5529 bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
5530
5531 insn = PLT_ENTRY_WORD4
5532 + (((unsigned int) ((-(h->plt.offset + 16)) >> 1)) & 0xffffff);
5533 bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
5534 local_plt_offset = 12;
5535 }
5536 else
5537 {
5538 /* sda_base must be set at this time. */
5539 unsigned long insn;
5540 long offset;
5541
5542 /* FIXME, sda_base is 65536, it will damage opcode. */
5543 /* insn = PLT_PIC_ENTRY_WORD0 + (((got_offset - sda_base) >> 2) & 0x7fff); */
5544 offset = sgot->output_section->vma + sgot->output_offset + got_offset
5545 - elf_gp (output_bfd);
5546 insn = PLT_PIC_ENTRY_WORD0 + ((offset >> 12) & 0xfffff);
5547 bfd_putb32 (insn, splt->contents + h->plt.offset);
5548
5549 insn = PLT_PIC_ENTRY_WORD1 + (offset & 0xfff);
5550 bfd_putb32 (insn, splt->contents + h->plt.offset + 4);
5551
5552 insn = PLT_PIC_ENTRY_WORD2;
5553 bfd_putb32 (insn, splt->contents + h->plt.offset + 8);
5554
5555 insn = PLT_PIC_ENTRY_WORD3;
5556 bfd_putb32 (insn, splt->contents + h->plt.offset + 12);
5557
5558 insn = PLT_PIC_ENTRY_WORD4 + (plt_index & 0x7fffff);
5559 bfd_putb32 (insn, splt->contents + h->plt.offset + 16);
5560
5561 insn = PLT_PIC_ENTRY_WORD5
5562 + (((unsigned int) ((-(h->plt.offset + 20)) >> 1)) & 0xffffff);
5563 bfd_putb32 (insn, splt->contents + h->plt.offset + 20);
5564
5565 local_plt_offset = 16;
5566 }
5567
5568 /* Fill in the entry in the global offset table,
5569 so it will fall through to the next instruction for the first time. */
5570 bfd_put_32 (output_bfd,
5571 (splt->output_section->vma + splt->output_offset
5572 + h->plt.offset + local_plt_offset),
5573 sgot->contents + got_offset);
5574
5575 /* Fill in the entry in the .rela.plt section. */
5576 rela.r_offset = (sgot->output_section->vma
5577 + sgot->output_offset + got_offset);
5578 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_JMP_SLOT);
5579 rela.r_addend = 0;
5580 loc = srela->contents;
5581 loc += plt_index * sizeof (Elf32_External_Rela);
5582 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5583
5584 if (!h->def_regular)
5585 {
5586 /* Mark the symbol as undefined, rather than as defined in
5587 the .plt section. Leave the value alone. */
5588 sym->st_shndx = SHN_UNDEF;
5589 if (!h->ref_regular_nonweak)
5590 sym->st_value = 0;
5591 }
5592 }
5593
5594 if (h->got.offset != (bfd_vma) - 1)
5595 {
5596 asection *sgot;
5597 asection *srela;
5598 Elf_Internal_Rela rela;
5599
5600 /* This symbol has an entry in the global offset table.
5601 Set it up. */
5602
5603 sgot = htab->sgot;
5604 srela = htab->srelgot;
5605 BFD_ASSERT (sgot != NULL && srela != NULL);
5606
5607 rela.r_offset = (sgot->output_section->vma
5608 + sgot->output_offset + (h->got.offset & ~1));
5609
5610 /* If this is a -Bsymbolic link, and the symbol is defined
5611 locally, we just want to emit a RELATIVE reloc. Likewise if
5612 the symbol was forced to be local because of a version file.
5613 The entry in the global offset table will already have been
5614 initialized in the relocate_section function. */
5615 if (bfd_link_pic (info)
5616 && (info->symbolic
5617 || h->dynindx == -1 || h->forced_local) && h->def_regular)
5618 {
5619 rela.r_info = ELF32_R_INFO (0, R_NDS32_RELATIVE);
5620 rela.r_addend = (h->root.u.def.value
5621 + h->root.u.def.section->output_section->vma
5622 + h->root.u.def.section->output_offset);
5623 }
5624 else
5625 {
5626 BFD_ASSERT ((h->got.offset & 1) == 0);
5627 bfd_put_32 (output_bfd, (bfd_vma) 0,
5628 sgot->contents + h->got.offset);
5629 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_GLOB_DAT);
5630 rela.r_addend = 0;
5631 }
5632
5633 loc = srela->contents;
5634 loc += srela->reloc_count * sizeof (Elf32_External_Rela);
5635 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5636 ++srela->reloc_count;
5637 }
5638
5639 if (h->needs_copy)
5640 {
5641 asection *s;
5642 Elf_Internal_Rela rela;
5643
5644 /* This symbols needs a copy reloc. Set it up. */
5645
5646 BFD_ASSERT (h->dynindx != -1
5647 && (h->root.type == bfd_link_hash_defined
5648 || h->root.type == bfd_link_hash_defweak));
5649
5650 s = bfd_get_section_by_name (h->root.u.def.section->owner, ".rela.bss");
5651 BFD_ASSERT (s != NULL);
5652
5653 rela.r_offset = (h->root.u.def.value
5654 + h->root.u.def.section->output_section->vma
5655 + h->root.u.def.section->output_offset);
5656 rela.r_info = ELF32_R_INFO (h->dynindx, R_NDS32_COPY);
5657 rela.r_addend = 0;
5658 loc = s->contents;
5659 loc += s->reloc_count * sizeof (Elf32_External_Rela);
5660 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5661 ++s->reloc_count;
5662 }
5663
5664 /* Mark some specially defined symbols as absolute. */
5665 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5666 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
5667 sym->st_shndx = SHN_ABS;
5668
5669 return TRUE;
5670 }
5671
5672
5673 /* Finish up the dynamic sections. */
5674
5675 static bfd_boolean
5676 nds32_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
5677 {
5678 struct elf_nds32_link_hash_table *htab;
5679 bfd *dynobj;
5680 asection *sdyn;
5681 asection *sgot;
5682
5683 htab = nds32_elf_hash_table (info);
5684 dynobj = htab->root.dynobj;
5685
5686 sgot = htab->sgotplt;
5687 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5688
5689 if (htab->root.dynamic_sections_created)
5690 {
5691 asection *splt;
5692 Elf32_External_Dyn *dyncon, *dynconend;
5693
5694 BFD_ASSERT (sgot != NULL && sdyn != NULL);
5695
5696 dyncon = (Elf32_External_Dyn *) sdyn->contents;
5697 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5698
5699 for (; dyncon < dynconend; dyncon++)
5700 {
5701 Elf_Internal_Dyn dyn;
5702 asection *s;
5703
5704 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5705
5706 switch (dyn.d_tag)
5707 {
5708 default:
5709 break;
5710
5711 case DT_PLTGOT:
5712 s = htab->sgotplt;
5713 goto get_vma;
5714 case DT_JMPREL:
5715 s = htab->srelplt;
5716 get_vma:
5717 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5718 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5719 break;
5720
5721 case DT_PLTRELSZ:
5722 s = htab->srelplt;
5723 dyn.d_un.d_val = s->size;
5724 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5725 break;
5726
5727 case DT_RELASZ:
5728 /* My reading of the SVR4 ABI indicates that the
5729 procedure linkage table relocs (DT_JMPREL) should be
5730 included in the overall relocs (DT_RELA). This is
5731 what Solaris does. However, UnixWare can not handle
5732 that case. Therefore, we override the DT_RELASZ entry
5733 here to make it not include the JMPREL relocs. Since
5734 the linker script arranges for .rela.plt to follow all
5735 other relocation sections, we don't have to worry
5736 about changing the DT_RELA entry. */
5737 if (htab->srelplt != NULL)
5738 {
5739 s = htab->srelplt;
5740 dyn.d_un.d_val -= s->size;
5741 }
5742 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5743 break;
5744 }
5745 }
5746
5747 /* Fill in the first entry in the procedure linkage table. */
5748 splt = htab->splt;
5749 if (splt && splt->size > 0)
5750 {
5751 if (bfd_link_pic (info))
5752 {
5753 unsigned long insn;
5754 long offset;
5755
5756 /* FIXME, sda_base is 65536, it will damage opcode. */
5757 /* insn = PLT_PIC_ENTRY_WORD0 + (((got_offset - sda_base) >> 2) & 0x7fff); */
5758 offset = sgot->output_section->vma + sgot->output_offset + 4
5759 - elf_gp (output_bfd);
5760 insn = PLT0_PIC_ENTRY_WORD0 | ((offset >> 12) & 0xfffff);
5761 bfd_putb32 (insn, splt->contents);
5762
5763 /* insn = PLT0_PIC_ENTRY_WORD0 | (((8 - sda_base) >> 2) & 0x7fff) ; */
5764 /* here has a typo? */
5765 insn = PLT0_PIC_ENTRY_WORD1 | (offset & 0xfff);
5766 bfd_putb32 (insn, splt->contents + 4);
5767
5768 insn = PLT0_PIC_ENTRY_WORD2;
5769 bfd_putb32 (insn, splt->contents + 8);
5770
5771 insn = PLT0_PIC_ENTRY_WORD3;
5772 bfd_putb32 (insn, splt->contents + 12);
5773
5774 insn = PLT0_PIC_ENTRY_WORD4;
5775 bfd_putb32 (insn, splt->contents + 16);
5776
5777 insn = PLT0_PIC_ENTRY_WORD5;
5778 bfd_putb32 (insn, splt->contents + 20);
5779 }
5780 else
5781 {
5782 unsigned long insn;
5783 unsigned long addr;
5784
5785 /* addr = .got + 4 */
5786 addr = sgot->output_section->vma + sgot->output_offset + 4;
5787 insn = PLT0_ENTRY_WORD0 | ((addr >> 12) & 0xfffff);
5788 bfd_putb32 (insn, splt->contents);
5789
5790 insn = PLT0_ENTRY_WORD1 | (addr & 0x0fff);
5791 bfd_putb32 (insn, splt->contents + 4);
5792
5793 insn = PLT0_ENTRY_WORD2;
5794 bfd_putb32 (insn, splt->contents + 8);
5795
5796 insn = PLT0_ENTRY_WORD3;
5797 bfd_putb32 (insn, splt->contents + 12);
5798
5799 insn = PLT0_ENTRY_WORD4;
5800 bfd_putb32 (insn, splt->contents + 16);
5801 }
5802
5803 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
5804 PLT_ENTRY_SIZE;
5805 }
5806 }
5807
5808 /* Fill in the first three entries in the global offset table. */
5809 if (sgot && sgot->size > 0)
5810 {
5811 if (sdyn == NULL)
5812 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
5813 else
5814 bfd_put_32 (output_bfd,
5815 sdyn->output_section->vma + sdyn->output_offset,
5816 sgot->contents);
5817 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
5818 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
5819
5820 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
5821 }
5822
5823 return TRUE;
5824 }
5825 \f
5826
5827 /* Set the right machine number. */
5828
5829 static bfd_boolean
5830 nds32_elf_object_p (bfd *abfd)
5831 {
5832 static unsigned int cur_arch = 0;
5833
5834 if (E_N1_ARCH != (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH))
5835 {
5836 /* E_N1_ARCH is a wild card, so it is set only when no others exist. */
5837 cur_arch = (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH);
5838 }
5839
5840 switch (cur_arch)
5841 {
5842 default:
5843 case E_N1_ARCH:
5844 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1);
5845 break;
5846 case E_N1H_ARCH:
5847 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h);
5848 break;
5849 case E_NDS_ARCH_STAR_V2_0:
5850 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v2);
5851 break;
5852 case E_NDS_ARCH_STAR_V3_0:
5853 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3);
5854 break;
5855 case E_NDS_ARCH_STAR_V3_M:
5856 bfd_default_set_arch_mach (abfd, bfd_arch_nds32, bfd_mach_n1h_v3m);
5857 break;
5858 }
5859
5860 return TRUE;
5861 }
5862
5863 /* Store the machine number in the flags field. */
5864
5865 static void
5866 nds32_elf_final_write_processing (bfd *abfd,
5867 bfd_boolean linker ATTRIBUTE_UNUSED)
5868 {
5869 unsigned long val;
5870 static unsigned int cur_mach = 0;
5871
5872 if (bfd_mach_n1 != bfd_get_mach (abfd))
5873 {
5874 cur_mach = bfd_get_mach (abfd);
5875 }
5876
5877 switch (cur_mach)
5878 {
5879 case bfd_mach_n1:
5880 /* Only happen when object is empty, since the case is abandon. */
5881 val = E_N1_ARCH;
5882 val |= E_NDS_ABI_AABI;
5883 val |= E_NDS32_ELF_VER_1_4;
5884 break;
5885 case bfd_mach_n1h:
5886 val = E_N1H_ARCH;
5887 break;
5888 case bfd_mach_n1h_v2:
5889 val = E_NDS_ARCH_STAR_V2_0;
5890 break;
5891 case bfd_mach_n1h_v3:
5892 val = E_NDS_ARCH_STAR_V3_0;
5893 break;
5894 case bfd_mach_n1h_v3m:
5895 val = E_NDS_ARCH_STAR_V3_M;
5896 break;
5897 default:
5898 val = 0;
5899 break;
5900 }
5901
5902 elf_elfheader (abfd)->e_flags &= ~EF_NDS_ARCH;
5903 elf_elfheader (abfd)->e_flags |= val;
5904 }
5905
5906 /* Function to keep NDS32 specific file flags. */
5907
5908 static bfd_boolean
5909 nds32_elf_set_private_flags (bfd *abfd, flagword flags)
5910 {
5911 BFD_ASSERT (!elf_flags_init (abfd)
5912 || elf_elfheader (abfd)->e_flags == flags);
5913
5914 elf_elfheader (abfd)->e_flags = flags;
5915 elf_flags_init (abfd) = TRUE;
5916 return TRUE;
5917 }
5918
5919 static unsigned int
5920 convert_e_flags (unsigned int e_flags, unsigned int arch)
5921 {
5922 if ((e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9)
5923 {
5924 /* From 0.9 to 1.0. */
5925 e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V1_0;
5926
5927 /* Invert E_NDS32_HAS_NO_MAC_INST. */
5928 e_flags ^= E_NDS32_HAS_NO_MAC_INST;
5929 if (arch == E_NDS_ARCH_STAR_V1_0)
5930 {
5931 /* Done. */
5932 return e_flags;
5933 }
5934 }
5935
5936 /* From 1.0 to 2.0. */
5937 e_flags = (e_flags & (~EF_NDS_ARCH)) | E_NDS_ARCH_STAR_V2_0;
5938
5939 /* Clear E_NDS32_HAS_MFUSR_PC_INST. */
5940 e_flags &= ~E_NDS32_HAS_MFUSR_PC_INST;
5941
5942 /* Invert E_NDS32_HAS_NO_MAC_INST. */
5943 e_flags ^= E_NDS32_HAS_NO_MAC_INST;
5944 return e_flags;
5945 }
5946
5947 static bfd_boolean
5948 nds32_check_vec_size (bfd *ibfd)
5949 {
5950 static unsigned int nds32_vec_size = 0;
5951
5952 asection *sec_t = NULL;
5953 bfd_byte *contents = NULL;
5954
5955 sec_t = bfd_get_section_by_name (ibfd, ".nds32_e_flags");
5956
5957 if (sec_t && sec_t->size >= 4)
5958 {
5959 /* Get vec_size in file. */
5960 unsigned int flag_t;
5961
5962 nds32_get_section_contents (ibfd, sec_t, &contents, TRUE);
5963 flag_t = bfd_get_32 (ibfd, contents);
5964
5965 /* The value could only be 4 or 16. */
5966
5967 if (!nds32_vec_size)
5968 /* Set if not set yet. */
5969 nds32_vec_size = (flag_t & 0x3);
5970 else if (nds32_vec_size != (flag_t & 0x3))
5971 {
5972 _bfd_error_handler
5973 (_("%B: ISR vector size mismatch"
5974 " with previous modules, previous %u-byte, current %u-byte"),
5975 ibfd,
5976 nds32_vec_size == 1 ? 4 : nds32_vec_size == 2 ? 16 : 0xffffffff,
5977 (flag_t & 0x3) == 1 ? 4 : (flag_t & 0x3) == 2 ? 16 : 0xffffffff);
5978 return FALSE;
5979 }
5980 else
5981 /* Only keep the first vec_size section. */
5982 sec_t->flags |= SEC_EXCLUDE;
5983 }
5984
5985 return TRUE;
5986 }
5987
5988 /* Merge backend specific data from an object file to the output
5989 object file when linking. */
5990
5991 static bfd_boolean
5992 nds32_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
5993 {
5994 bfd *obfd = info->output_bfd;
5995 flagword out_flags;
5996 flagword in_flags;
5997 flagword out_16regs;
5998 flagword in_no_mac;
5999 flagword out_no_mac;
6000 flagword in_16regs;
6001 flagword out_version;
6002 flagword in_version;
6003 flagword out_fpu_config;
6004 flagword in_fpu_config;
6005
6006 /* TODO: Revise to use object-attributes instead. */
6007 if (!nds32_check_vec_size (ibfd))
6008 return FALSE;
6009
6010 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6011 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6012 return TRUE;
6013
6014 if (bfd_little_endian (ibfd) != bfd_little_endian (obfd))
6015 {
6016 _bfd_error_handler
6017 (_("%B: warning: Endian mismatch with previous modules."), ibfd);
6018
6019 bfd_set_error (bfd_error_bad_value);
6020 return FALSE;
6021 }
6022
6023 in_version = elf_elfheader (ibfd)->e_flags & EF_NDS32_ELF_VERSION;
6024 if (in_version == E_NDS32_ELF_VER_1_2)
6025 {
6026 _bfd_error_handler
6027 (_("%B: warning: Older version of object file encountered, "
6028 "Please recompile with current tool chain."), ibfd);
6029 }
6030
6031 /* We may need to merge V1 and V2 arch object files to V2. */
6032 if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6033 != (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6034 {
6035 /* Need to convert version. */
6036 if ((elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6037 == E_NDS_ARCH_STAR_RESERVED)
6038 {
6039 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6040 }
6041 else if ((elf_elfheader (obfd)->e_flags & EF_NDS_ARCH) == E_NDS_ARCH_STAR_V0_9
6042 || (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH)
6043 > (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH))
6044 {
6045 elf_elfheader (obfd)->e_flags =
6046 convert_e_flags (elf_elfheader (obfd)->e_flags,
6047 (elf_elfheader (ibfd)->e_flags & EF_NDS_ARCH));
6048 }
6049 else
6050 {
6051 elf_elfheader (ibfd)->e_flags =
6052 convert_e_flags (elf_elfheader (ibfd)->e_flags,
6053 (elf_elfheader (obfd)->e_flags & EF_NDS_ARCH));
6054 }
6055 }
6056
6057 /* Extract some flags. */
6058 in_flags = elf_elfheader (ibfd)->e_flags
6059 & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6060 | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6061
6062 /* The following flags need special treatment. */
6063 in_16regs = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6064 in_no_mac = elf_elfheader (ibfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6065 in_fpu_config = elf_elfheader (ibfd)->e_flags & E_NDS32_FPU_REG_CONF;
6066
6067 /* Extract some flags. */
6068 out_flags = elf_elfheader (obfd)->e_flags
6069 & (~(E_NDS32_HAS_REDUCED_REGS | EF_NDS32_ELF_VERSION
6070 | E_NDS32_HAS_NO_MAC_INST | E_NDS32_FPU_REG_CONF));
6071
6072 /* The following flags need special treatment. */
6073 out_16regs = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_REDUCED_REGS;
6074 out_no_mac = elf_elfheader (obfd)->e_flags & E_NDS32_HAS_NO_MAC_INST;
6075 out_fpu_config = elf_elfheader (obfd)->e_flags & E_NDS32_FPU_REG_CONF;
6076 out_version = elf_elfheader (obfd)->e_flags & EF_NDS32_ELF_VERSION;
6077 if (!elf_flags_init (obfd))
6078 {
6079 /* If the input is the default architecture then do not
6080 bother setting the flags for the output architecture,
6081 instead allow future merges to do this. If no future
6082 merges ever set these flags then they will retain their
6083 unitialised values, which surprise surprise, correspond
6084 to the default values. */
6085 if (bfd_get_arch_info (ibfd)->the_default)
6086 return TRUE;
6087
6088 elf_flags_init (obfd) = TRUE;
6089 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6090
6091 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
6092 && bfd_get_arch_info (obfd)->the_default)
6093 {
6094 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
6095 bfd_get_mach (ibfd));
6096 }
6097
6098 return TRUE;
6099 }
6100
6101 /* Check flag compatibility. */
6102 if ((in_flags & EF_NDS_ABI) != (out_flags & EF_NDS_ABI))
6103 {
6104 _bfd_error_handler
6105 (_("%B: error: ABI mismatch with previous modules."), ibfd);
6106
6107 bfd_set_error (bfd_error_bad_value);
6108 return FALSE;
6109 }
6110
6111 if ((in_flags & EF_NDS_ARCH) != (out_flags & EF_NDS_ARCH))
6112 {
6113 if (((in_flags & EF_NDS_ARCH) != E_N1_ARCH))
6114 {
6115 _bfd_error_handler
6116 (_("%B: error: Instruction set mismatch with previous modules."), ibfd);
6117
6118 bfd_set_error (bfd_error_bad_value);
6119 return FALSE;
6120 }
6121 }
6122
6123 /* When linking with V1.2 and V1.3 objects together the output is V1.2.
6124 and perf ext1 and DIV are mergerd to perf ext1. */
6125 if (in_version == E_NDS32_ELF_VER_1_2 || out_version == E_NDS32_ELF_VER_1_2)
6126 {
6127 elf_elfheader (obfd)->e_flags =
6128 (in_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6129 | (out_flags & (~(E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6130 | (((in_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6131 ? E_NDS32_HAS_EXT_INST : 0)
6132 | (((out_flags & (E_NDS32_HAS_EXT_INST | E_NDS32_HAS_DIV_INST)))
6133 ? E_NDS32_HAS_EXT_INST : 0)
6134 | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6135 | ((in_version > out_version) ? out_version : in_version);
6136 }
6137 else
6138 {
6139 if (in_version != out_version)
6140 _bfd_error_handler
6141 (_("%B: warning: Incompatible elf-versions %s and %s."),
6142 ibfd, nds32_elfver_strtab[out_version],
6143 nds32_elfver_strtab[in_version]);
6144
6145 elf_elfheader (obfd)->e_flags = in_flags | out_flags
6146 | (in_16regs & out_16regs) | (in_no_mac & out_no_mac)
6147 | (in_fpu_config > out_fpu_config ? in_fpu_config : out_fpu_config)
6148 | (in_version > out_version ? out_version : in_version);
6149 }
6150
6151 return TRUE;
6152 }
6153
6154 /* Display the flags field. */
6155
6156 static bfd_boolean
6157 nds32_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6158 {
6159 FILE *file = (FILE *) ptr;
6160
6161 BFD_ASSERT (abfd != NULL && ptr != NULL);
6162
6163 _bfd_elf_print_private_bfd_data (abfd, ptr);
6164
6165 fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
6166
6167 switch (elf_elfheader (abfd)->e_flags & EF_NDS_ARCH)
6168 {
6169 default:
6170 case E_N1_ARCH:
6171 fprintf (file, _(": n1 instructions"));
6172 break;
6173 case E_N1H_ARCH:
6174 fprintf (file, _(": n1h instructions"));
6175 break;
6176 }
6177
6178 fputc ('\n', file);
6179
6180 return TRUE;
6181 }
6182
6183 static unsigned int
6184 nds32_elf_action_discarded (asection *sec)
6185 {
6186
6187 if (strncmp
6188 (".gcc_except_table", sec->name, sizeof (".gcc_except_table") - 1) == 0)
6189 return 0;
6190
6191 return _bfd_elf_default_action_discarded (sec);
6192 }
6193
6194 static asection *
6195 nds32_elf_gc_mark_hook (asection *sec, struct bfd_link_info *info,
6196 Elf_Internal_Rela *rel, struct elf_link_hash_entry *h,
6197 Elf_Internal_Sym *sym)
6198 {
6199 if (h != NULL)
6200 switch (ELF32_R_TYPE (rel->r_info))
6201 {
6202 case R_NDS32_GNU_VTINHERIT:
6203 case R_NDS32_GNU_VTENTRY:
6204 case R_NDS32_RELA_GNU_VTINHERIT:
6205 case R_NDS32_RELA_GNU_VTENTRY:
6206 return NULL;
6207 }
6208
6209 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6210 }
6211
6212 static bfd_boolean
6213 nds32_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info, asection *sec,
6214 const Elf_Internal_Rela *relocs)
6215 {
6216 /* Update the got entry reference counts for the section being removed. */
6217 Elf_Internal_Shdr *symtab_hdr;
6218 struct elf_link_hash_entry **sym_hashes;
6219 bfd_signed_vma *local_got_refcounts;
6220 const Elf_Internal_Rela *rel, *relend;
6221
6222 elf_section_data (sec)->local_dynrel = NULL;
6223
6224 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6225 sym_hashes = elf_sym_hashes (abfd);
6226 local_got_refcounts = elf_local_got_refcounts (abfd);
6227
6228 relend = relocs + sec->reloc_count;
6229 for (rel = relocs; rel < relend; rel++)
6230 {
6231 unsigned long r_symndx;
6232 struct elf_link_hash_entry *h = NULL;
6233
6234 r_symndx = ELF32_R_SYM (rel->r_info);
6235 if (r_symndx >= symtab_hdr->sh_info)
6236 {
6237 /* External symbol. */
6238 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6239 while (h->root.type == bfd_link_hash_indirect
6240 || h->root.type == bfd_link_hash_warning)
6241 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6242 }
6243
6244 switch (ELF32_R_TYPE (rel->r_info))
6245 {
6246 case R_NDS32_GOT_HI20:
6247 case R_NDS32_GOT_LO12:
6248 case R_NDS32_GOT_LO15:
6249 case R_NDS32_GOT_LO19:
6250 case R_NDS32_GOT17S2_RELA:
6251 case R_NDS32_GOT15S2_RELA:
6252 case R_NDS32_GOTOFF:
6253 case R_NDS32_GOTOFF_HI20:
6254 case R_NDS32_GOTOFF_LO12:
6255 case R_NDS32_GOTOFF_LO15:
6256 case R_NDS32_GOTOFF_LO19:
6257 case R_NDS32_GOT20:
6258 case R_NDS32_GOTPC_HI20:
6259 case R_NDS32_GOTPC_LO12:
6260 case R_NDS32_GOTPC20:
6261 if (h != NULL)
6262 {
6263 if (h->got.refcount > 0)
6264 h->got.refcount--;
6265 }
6266 else
6267 {
6268 if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
6269 local_got_refcounts[r_symndx]--;
6270 }
6271 break;
6272
6273 case R_NDS32_16_RELA:
6274 case R_NDS32_20_RELA:
6275 case R_NDS32_5_RELA:
6276 case R_NDS32_32_RELA:
6277 case R_NDS32_HI20_RELA:
6278 case R_NDS32_LO12S3_RELA:
6279 case R_NDS32_LO12S2_RELA:
6280 case R_NDS32_LO12S2_DP_RELA:
6281 case R_NDS32_LO12S2_SP_RELA:
6282 case R_NDS32_LO12S1_RELA:
6283 case R_NDS32_LO12S0_RELA:
6284 case R_NDS32_LO12S0_ORI_RELA:
6285 case R_NDS32_SDA16S3_RELA:
6286 case R_NDS32_SDA17S2_RELA:
6287 case R_NDS32_SDA18S1_RELA:
6288 case R_NDS32_SDA19S0_RELA:
6289 case R_NDS32_SDA15S3_RELA:
6290 case R_NDS32_SDA15S2_RELA:
6291 case R_NDS32_SDA12S2_DP_RELA:
6292 case R_NDS32_SDA12S2_SP_RELA:
6293 case R_NDS32_SDA15S1_RELA:
6294 case R_NDS32_SDA15S0_RELA:
6295 case R_NDS32_SDA_FP7U2_RELA:
6296 case R_NDS32_15_PCREL_RELA:
6297 case R_NDS32_17_PCREL_RELA:
6298 case R_NDS32_25_PCREL_RELA:
6299 if (h != NULL)
6300 {
6301 struct elf_nds32_link_hash_entry *eh;
6302 struct elf_nds32_dyn_relocs **pp;
6303 struct elf_nds32_dyn_relocs *p;
6304
6305 if (!bfd_link_pic (info) && h->plt.refcount > 0)
6306 h->plt.refcount -= 1;
6307
6308 eh = (struct elf_nds32_link_hash_entry *) h;
6309
6310 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6311 if (p->sec == sec)
6312 {
6313 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
6314 || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA
6315 || ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA)
6316 p->pc_count -= 1;
6317 p->count -= 1;
6318 if (p->count == 0)
6319 *pp = p->next;
6320 break;
6321 }
6322 }
6323 break;
6324
6325 case R_NDS32_9_PLTREL:
6326 case R_NDS32_25_PLTREL:
6327 if (h != NULL)
6328 {
6329 if (h->plt.refcount > 0)
6330 h->plt.refcount--;
6331 }
6332 break;
6333
6334 default:
6335 break;
6336 }
6337 }
6338
6339 return TRUE;
6340 }
6341
6342 /* Look through the relocs for a section during the first phase.
6343 Since we don't do .gots or .plts, we just need to consider the
6344 virtual table relocs for gc. */
6345
6346 static bfd_boolean
6347 nds32_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
6348 asection *sec, const Elf_Internal_Rela *relocs)
6349 {
6350 Elf_Internal_Shdr *symtab_hdr;
6351 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
6352 const Elf_Internal_Rela *rel;
6353 const Elf_Internal_Rela *rel_end;
6354 struct elf_nds32_link_hash_table *htab;
6355 bfd *dynobj;
6356 asection *sreloc = NULL;
6357
6358 if (bfd_link_relocatable (info))
6359 return TRUE;
6360
6361 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6362 sym_hashes = elf_sym_hashes (abfd);
6363 sym_hashes_end =
6364 sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
6365 if (!elf_bad_symtab (abfd))
6366 sym_hashes_end -= symtab_hdr->sh_info;
6367
6368 htab = nds32_elf_hash_table (info);
6369 dynobj = htab->root.dynobj;
6370
6371 rel_end = relocs + sec->reloc_count;
6372 for (rel = relocs; rel < rel_end; rel++)
6373 {
6374 enum elf_nds32_reloc_type r_type;
6375 struct elf_link_hash_entry *h;
6376 unsigned long r_symndx;
6377 int tls_type, old_tls_type;
6378
6379 r_symndx = ELF32_R_SYM (rel->r_info);
6380 r_type = ELF32_R_TYPE (rel->r_info);
6381 if (r_symndx < symtab_hdr->sh_info)
6382 h = NULL;
6383 else
6384 {
6385 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6386 while (h->root.type == bfd_link_hash_indirect
6387 || h->root.type == bfd_link_hash_warning)
6388 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6389 }
6390
6391 /* Some relocs require a global offset table. We create
6392 got section here, since these relocation need got section
6393 and it is not created yet. */
6394 if (htab->sgot == NULL)
6395 {
6396 switch (r_type)
6397 {
6398 case R_NDS32_GOT_HI20:
6399 case R_NDS32_GOT_LO12:
6400 case R_NDS32_GOT_LO15:
6401 case R_NDS32_GOT_LO19:
6402 case R_NDS32_GOT17S2_RELA:
6403 case R_NDS32_GOT15S2_RELA:
6404 case R_NDS32_GOTOFF:
6405 case R_NDS32_GOTOFF_HI20:
6406 case R_NDS32_GOTOFF_LO12:
6407 case R_NDS32_GOTOFF_LO15:
6408 case R_NDS32_GOTOFF_LO19:
6409 case R_NDS32_GOTPC20:
6410 case R_NDS32_GOTPC_HI20:
6411 case R_NDS32_GOTPC_LO12:
6412 case R_NDS32_GOT20:
6413 case R_NDS32_TLS_IE_HI20:
6414 case R_NDS32_TLS_IE_LO12S2:
6415 if (dynobj == NULL)
6416 htab->root.dynobj = dynobj = abfd;
6417 if (!create_got_section (dynobj, info))
6418 return FALSE;
6419 break;
6420
6421 default:
6422 break;
6423 }
6424 }
6425
6426 switch ((int) r_type)
6427 {
6428 case R_NDS32_GOT_HI20:
6429 case R_NDS32_GOT_LO12:
6430 case R_NDS32_GOT_LO15:
6431 case R_NDS32_GOT_LO19:
6432 case R_NDS32_GOT20:
6433 case R_NDS32_TLS_IE_HI20:
6434 case R_NDS32_TLS_IE_LO12S2:
6435 switch (r_type)
6436 {
6437 case R_NDS32_TLS_IE_HI20:
6438 case R_NDS32_TLS_IE_LO12S2:
6439 tls_type = GOT_TLS_IE;
6440 break;
6441 default:
6442 tls_type = GOT_NORMAL;
6443 break;
6444 }
6445 if (h != NULL)
6446 {
6447 old_tls_type = elf32_nds32_hash_entry (h)->tls_type;
6448 h->got.refcount += 1;
6449 }
6450 else
6451 {
6452 bfd_signed_vma *local_got_refcounts;
6453
6454 /* This is a global offset table entry for a local
6455 symbol. */
6456 local_got_refcounts = elf_local_got_refcounts (abfd);
6457 if (local_got_refcounts == NULL)
6458 {
6459 bfd_size_type size;
6460
6461 size = symtab_hdr->sh_info;
6462 size *= sizeof (bfd_signed_vma);
6463 local_got_refcounts = (bfd_signed_vma *) bfd_zalloc (abfd, size);
6464 if (local_got_refcounts == NULL)
6465 return FALSE;
6466 elf_local_got_refcounts (abfd) = local_got_refcounts;
6467 }
6468 local_got_refcounts[r_symndx] += 1;
6469 old_tls_type = elf32_nds32_local_got_tls_type (abfd)[r_symndx];
6470 }
6471
6472 /* We will already have issued an error message if there
6473 is a TLS/non-TLS mismatch, based on the symbol
6474 type. So just combine any TLS types needed. */
6475 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
6476 && tls_type != GOT_NORMAL)
6477 tls_type |= old_tls_type;
6478
6479 if (old_tls_type != tls_type)
6480 {
6481 if (h != NULL)
6482 elf32_nds32_hash_entry (h)->tls_type = tls_type;
6483 else
6484 elf32_nds32_local_got_tls_type (abfd)[r_symndx] = tls_type;
6485 }
6486 break;
6487 case R_NDS32_9_PLTREL:
6488 case R_NDS32_25_PLTREL:
6489 case R_NDS32_PLTREL_HI20:
6490 case R_NDS32_PLTREL_LO12:
6491 case R_NDS32_PLT_GOTREL_HI20:
6492 case R_NDS32_PLT_GOTREL_LO12:
6493 case R_NDS32_PLT_GOTREL_LO15:
6494 case R_NDS32_PLT_GOTREL_LO19:
6495 case R_NDS32_PLT_GOTREL_LO20:
6496
6497 /* This symbol requires a procedure linkage table entry. We
6498 actually build the entry in adjust_dynamic_symbol,
6499 because this might be a case of linking PIC code without
6500 linking in any dynamic objects, in which case we don't
6501 need to generate a procedure linkage table after all. */
6502
6503 /* If this is a local symbol, we resolve it directly without
6504 creating a procedure linkage table entry. */
6505 if (h == NULL)
6506 continue;
6507
6508 if (h->forced_local)
6509 break;
6510
6511 elf32_nds32_hash_entry (h)->tls_type = GOT_NORMAL;
6512 h->needs_plt = 1;
6513 h->plt.refcount += 1;
6514 break;
6515
6516 case R_NDS32_16_RELA:
6517 case R_NDS32_20_RELA:
6518 case R_NDS32_5_RELA:
6519 case R_NDS32_32_RELA:
6520 case R_NDS32_HI20_RELA:
6521 case R_NDS32_LO12S3_RELA:
6522 case R_NDS32_LO12S2_RELA:
6523 case R_NDS32_LO12S2_DP_RELA:
6524 case R_NDS32_LO12S2_SP_RELA:
6525 case R_NDS32_LO12S1_RELA:
6526 case R_NDS32_LO12S0_RELA:
6527 case R_NDS32_LO12S0_ORI_RELA:
6528 case R_NDS32_SDA16S3_RELA:
6529 case R_NDS32_SDA17S2_RELA:
6530 case R_NDS32_SDA18S1_RELA:
6531 case R_NDS32_SDA19S0_RELA:
6532 case R_NDS32_SDA15S3_RELA:
6533 case R_NDS32_SDA15S2_RELA:
6534 case R_NDS32_SDA12S2_DP_RELA:
6535 case R_NDS32_SDA12S2_SP_RELA:
6536 case R_NDS32_SDA15S1_RELA:
6537 case R_NDS32_SDA15S0_RELA:
6538 case R_NDS32_SDA_FP7U2_RELA:
6539 case R_NDS32_15_PCREL_RELA:
6540 case R_NDS32_17_PCREL_RELA:
6541 case R_NDS32_25_PCREL_RELA:
6542
6543 if (h != NULL && !bfd_link_pic (info))
6544 {
6545 h->non_got_ref = 1;
6546 h->plt.refcount += 1;
6547 }
6548
6549 /* If we are creating a shared library, and this is a reloc against
6550 a global symbol, or a non PC relative reloc against a local
6551 symbol, then we need to copy the reloc into the shared library.
6552 However, if we are linking with -Bsymbolic, we do not need to
6553 copy a reloc against a global symbol which is defined in an
6554 object we are including in the link (i.e., DEF_REGULAR is set).
6555 At this point we have not seen all the input files, so it is
6556 possible that DEF_REGULAR is not set now but will be set later
6557 (it is never cleared). We account for that possibility below by
6558 storing information in the dyn_relocs field of the hash table
6559 entry. A similar situation occurs when creating shared libraries
6560 and symbol visibility changes render the symbol local.
6561
6562 If on the other hand, we are creating an executable, we may need
6563 to keep relocations for symbols satisfied by a dynamic library
6564 if we manage to avoid copy relocs for the symbol. */
6565 if ((bfd_link_pic (info)
6566 && (sec->flags & SEC_ALLOC) != 0
6567 && ((r_type != R_NDS32_25_PCREL_RELA
6568 && r_type != R_NDS32_15_PCREL_RELA
6569 && r_type != R_NDS32_17_PCREL_RELA
6570 && !(r_type == R_NDS32_32_RELA
6571 && strcmp (sec->name, ".eh_frame") == 0))
6572 || (h != NULL
6573 && (!info->symbolic
6574 || h->root.type == bfd_link_hash_defweak
6575 || !h->def_regular))))
6576 || (!bfd_link_pic (info)
6577 && (sec->flags & SEC_ALLOC) != 0
6578 && h != NULL
6579 && (h->root.type == bfd_link_hash_defweak
6580 || !h->def_regular)))
6581 {
6582 struct elf_nds32_dyn_relocs *p;
6583 struct elf_nds32_dyn_relocs **head;
6584
6585 if (dynobj == NULL)
6586 htab->root.dynobj = dynobj = abfd;
6587
6588 /* When creating a shared object, we must copy these
6589 relocs into the output file. We create a reloc
6590 section in dynobj and make room for the reloc. */
6591 if (sreloc == NULL)
6592 {
6593 const char *name;
6594
6595 name = bfd_elf_string_from_elf_section
6596 (abfd, elf_elfheader (abfd)->e_shstrndx,
6597 elf_section_data (sec)->rela.hdr->sh_name);
6598 if (name == NULL)
6599 return FALSE;
6600
6601 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
6602 && strcmp (bfd_get_section_name (abfd, sec),
6603 name + 5) == 0);
6604
6605 sreloc = bfd_get_section_by_name (dynobj, name);
6606 if (sreloc == NULL)
6607 {
6608 flagword flags;
6609
6610 sreloc = bfd_make_section (dynobj, name);
6611 flags = (SEC_HAS_CONTENTS | SEC_READONLY
6612 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6613 if ((sec->flags & SEC_ALLOC) != 0)
6614 flags |= SEC_ALLOC | SEC_LOAD;
6615 if (sreloc == NULL
6616 || !bfd_set_section_flags (dynobj, sreloc, flags)
6617 || !bfd_set_section_alignment (dynobj, sreloc, 2))
6618 return FALSE;
6619
6620 elf_section_type (sreloc) = SHT_RELA;
6621 }
6622 elf_section_data (sec)->sreloc = sreloc;
6623 }
6624
6625 /* If this is a global symbol, we count the number of
6626 relocations we need for this symbol. */
6627 if (h != NULL)
6628 head = &((struct elf_nds32_link_hash_entry *) h)->dyn_relocs;
6629 else
6630 {
6631 asection *s;
6632 void *vpp;
6633
6634 Elf_Internal_Sym *isym;
6635 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx);
6636 if (isym == NULL)
6637 return FALSE;
6638
6639 /* Track dynamic relocs needed for local syms too. */
6640 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6641 if (s == NULL)
6642 return FALSE;
6643
6644 vpp = &elf_section_data (s)->local_dynrel;
6645 head = (struct elf_nds32_dyn_relocs **) vpp;
6646 }
6647
6648 p = *head;
6649 if (p == NULL || p->sec != sec)
6650 {
6651 bfd_size_type amt = sizeof (*p);
6652 p = (struct elf_nds32_dyn_relocs *) bfd_alloc (dynobj, amt);
6653 if (p == NULL)
6654 return FALSE;
6655 p->next = *head;
6656 *head = p;
6657 p->sec = sec;
6658 p->count = 0;
6659 p->pc_count = 0;
6660 }
6661
6662 p->count += 1;
6663 if (ELF32_R_TYPE (rel->r_info) == R_NDS32_25_PCREL_RELA
6664 || ELF32_R_TYPE (rel->r_info) == R_NDS32_15_PCREL_RELA
6665 || ELF32_R_TYPE (rel->r_info) == R_NDS32_17_PCREL_RELA)
6666 p->pc_count += 1;
6667 }
6668 break;
6669
6670 /* This relocation describes the C++ object vtable hierarchy.
6671 Reconstruct it for later use during GC. */
6672 case R_NDS32_RELA_GNU_VTINHERIT:
6673 case R_NDS32_GNU_VTINHERIT:
6674 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6675 return FALSE;
6676 break;
6677
6678 /* This relocation describes which C++ vtable entries are actually
6679 used. Record for later use during GC. */
6680 case R_NDS32_GNU_VTENTRY:
6681 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
6682 return FALSE;
6683 break;
6684 case R_NDS32_RELA_GNU_VTENTRY:
6685 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6686 return FALSE;
6687 break;
6688 }
6689 }
6690
6691 return TRUE;
6692 }
6693
6694 /* Write VAL in uleb128 format to P, returning a pointer to the
6695 following byte.
6696 This code is copied from elf-attr.c. */
6697
6698 static bfd_byte *
6699 write_uleb128 (bfd_byte *p, unsigned int val)
6700 {
6701 bfd_byte c;
6702 do
6703 {
6704 c = val & 0x7f;
6705 val >>= 7;
6706 if (val)
6707 c |= 0x80;
6708 *(p++) = c;
6709 }
6710 while (val);
6711 return p;
6712 }
6713
6714 static bfd_signed_vma
6715 calculate_offset (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
6716 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr,
6717 int *pic_ext_target)
6718 {
6719 bfd_signed_vma foff;
6720 bfd_vma symval, addend;
6721 asection *sym_sec;
6722
6723 /* Get the value of the symbol referred to by the reloc. */
6724 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
6725 {
6726 Elf_Internal_Sym *isym;
6727
6728 /* A local symbol. */
6729 isym = isymbuf + ELF32_R_SYM (irel->r_info);
6730
6731 if (isym->st_shndx == SHN_UNDEF)
6732 sym_sec = bfd_und_section_ptr;
6733 else if (isym->st_shndx == SHN_ABS)
6734 sym_sec = bfd_abs_section_ptr;
6735 else if (isym->st_shndx == SHN_COMMON)
6736 sym_sec = bfd_com_section_ptr;
6737 else
6738 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6739 symval = isym->st_value + sym_sec->output_section->vma
6740 + sym_sec->output_offset;
6741 }
6742 else
6743 {
6744 unsigned long indx;
6745 struct elf_link_hash_entry *h;
6746 bfd *owner;
6747
6748 /* An external symbol. */
6749 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6750 h = elf_sym_hashes (abfd)[indx];
6751 BFD_ASSERT (h != NULL);
6752
6753 if (h->root.type != bfd_link_hash_defined
6754 && h->root.type != bfd_link_hash_defweak)
6755 /* This appears to be a reference to an undefined
6756 symbol. Just ignore it--it will be caught by the
6757 regular reloc processing. */
6758 return 0;
6759 owner = h->root.u.def.section->owner;
6760 if (owner && (elf_elfheader (owner)->e_flags & E_NDS32_HAS_PIC))
6761 *pic_ext_target = 1;
6762
6763 if (h->root.u.def.section->flags & SEC_MERGE)
6764 {
6765 sym_sec = h->root.u.def.section;
6766 symval = _bfd_merged_section_offset (abfd, &sym_sec,
6767 elf_section_data (sym_sec)->sec_info,
6768 h->root.u.def.value);
6769 symval = symval + sym_sec->output_section->vma
6770 + sym_sec->output_offset;
6771 }
6772 else
6773 symval = (h->root.u.def.value
6774 + h->root.u.def.section->output_section->vma
6775 + h->root.u.def.section->output_offset);
6776 }
6777
6778 addend = irel->r_addend;
6779
6780 foff = (symval + addend
6781 - (irel->r_offset + sec->output_section->vma + sec->output_offset));
6782 return foff;
6783 }
6784
6785 static bfd_vma
6786 calculate_plt_memory_address (bfd *abfd, struct bfd_link_info *link_info,
6787 Elf_Internal_Sym *isymbuf,
6788 Elf_Internal_Rela *irel,
6789 Elf_Internal_Shdr *symtab_hdr)
6790 {
6791 bfd_vma symval;
6792
6793 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
6794 {
6795 Elf_Internal_Sym *isym;
6796 asection *sym_sec;
6797 /* A local symbol. */
6798 isym = isymbuf + ELF32_R_SYM (irel->r_info);
6799
6800 if (isym->st_shndx == SHN_UNDEF)
6801 sym_sec = bfd_und_section_ptr;
6802 else if (isym->st_shndx == SHN_ABS)
6803 sym_sec = bfd_abs_section_ptr;
6804 else if (isym->st_shndx == SHN_COMMON)
6805 sym_sec = bfd_com_section_ptr;
6806 else
6807 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6808 symval = isym->st_value + sym_sec->output_section->vma
6809 + sym_sec->output_offset;
6810 }
6811 else
6812 {
6813 unsigned long indx;
6814 struct elf_link_hash_entry *h;
6815 struct elf_nds32_link_hash_table *htab;
6816 asection *splt;
6817
6818 /* An external symbol. */
6819 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
6820 h = elf_sym_hashes (abfd)[indx];
6821 BFD_ASSERT (h != NULL);
6822 htab = nds32_elf_hash_table (link_info);
6823 splt = htab->splt;
6824
6825 while (h->root.type == bfd_link_hash_indirect
6826 || h->root.type == bfd_link_hash_warning)
6827 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6828
6829 if (h->plt.offset == (bfd_vma) - 1)
6830 {
6831 if (h->root.type != bfd_link_hash_defined
6832 && h->root.type != bfd_link_hash_defweak)
6833 /* This appears to be a reference to an undefined
6834 * symbol. Just ignore it--it will be caught by the
6835 * regular reloc processing. */
6836 return 0;
6837 symval = (h->root.u.def.value
6838 + h->root.u.def.section->output_section->vma
6839 + h->root.u.def.section->output_offset);
6840 }
6841 else
6842 symval = splt->output_section->vma + h->plt.offset;
6843 }
6844
6845 return symval;
6846 }
6847
6848 static bfd_signed_vma
6849 calculate_plt_offset (bfd *abfd, asection *sec, struct bfd_link_info *link_info,
6850 Elf_Internal_Sym *isymbuf, Elf_Internal_Rela *irel,
6851 Elf_Internal_Shdr *symtab_hdr)
6852 {
6853 bfd_vma foff;
6854 if ((foff = calculate_plt_memory_address (abfd, link_info, isymbuf, irel,
6855 symtab_hdr)) == 0)
6856 return 0;
6857 else
6858 return foff - (irel->r_offset
6859 + sec->output_section->vma + sec->output_offset);
6860 }
6861 \f
6862 /* Convert a 32-bit instruction to 16-bit one.
6863 INSN is the input 32-bit instruction, INSN16 is the output 16-bit
6864 instruction. If INSN_TYPE is not NULL, it the CGEN instruction
6865 type of INSN16. Return 1 if successful. */
6866
6867 static int
6868 nds32_convert_32_to_16_alu1 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
6869 int *pinsn_type)
6870 {
6871 uint16_t insn16 = 0;
6872 int insn_type = 0;
6873 unsigned long mach = bfd_get_mach (abfd);
6874
6875 if (N32_SH5 (insn) != 0)
6876 return 0;
6877
6878 switch (N32_SUB5 (insn))
6879 {
6880 case N32_ALU1_ADD_SLLI:
6881 case N32_ALU1_ADD_SRLI:
6882 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
6883 {
6884 insn16 = N16_TYPE333 (ADD333, N32_RT5 (insn), N32_RA5 (insn),
6885 N32_RB5 (insn));
6886 insn_type = NDS32_INSN_ADD333;
6887 }
6888 else if (N32_IS_RT4 (insn))
6889 {
6890 if (N32_RT5 (insn) == N32_RA5 (insn))
6891 insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RB5 (insn));
6892 else if (N32_RT5 (insn) == N32_RB5 (insn))
6893 insn16 = N16_TYPE45 (ADD45, N32_RT54 (insn), N32_RA5 (insn));
6894 insn_type = NDS32_INSN_ADD45;
6895 }
6896 break;
6897
6898 case N32_ALU1_SUB_SLLI:
6899 case N32_ALU1_SUB_SRLI:
6900 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IS_RB3 (insn))
6901 {
6902 insn16 = N16_TYPE333 (SUB333, N32_RT5 (insn), N32_RA5 (insn),
6903 N32_RB5 (insn));
6904 insn_type = NDS32_INSN_SUB333;
6905 }
6906 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6907 {
6908 insn16 = N16_TYPE45 (SUB45, N32_RT54 (insn), N32_RB5 (insn));
6909 insn_type = NDS32_INSN_SUB45;
6910 }
6911 break;
6912
6913 case N32_ALU1_AND_SLLI:
6914 case N32_ALU1_AND_SRLI:
6915 /* and $rt, $rt, $rb -> and33 for v3, v3m. */
6916 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6917 && N32_IS_RB3 (insn))
6918 {
6919 if (N32_RT5 (insn) == N32_RA5 (insn))
6920 insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RB5 (insn));
6921 else if (N32_RT5 (insn) == N32_RB5 (insn))
6922 insn16 = N16_MISC33 (AND33, N32_RT5 (insn), N32_RA5 (insn));
6923 if (insn16)
6924 insn_type = NDS32_INSN_AND33;
6925 }
6926 break;
6927
6928 case N32_ALU1_XOR_SLLI:
6929 case N32_ALU1_XOR_SRLI:
6930 /* xor $rt, $rt, $rb -> xor33 for v3, v3m. */
6931 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6932 && N32_IS_RB3 (insn))
6933 {
6934 if (N32_RT5 (insn) == N32_RA5 (insn))
6935 insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RB5 (insn));
6936 else if (N32_RT5 (insn) == N32_RB5 (insn))
6937 insn16 = N16_MISC33 (XOR33, N32_RT5 (insn), N32_RA5 (insn));
6938 if (insn16)
6939 insn_type = NDS32_INSN_XOR33;
6940 }
6941 break;
6942
6943 case N32_ALU1_OR_SLLI:
6944 case N32_ALU1_OR_SRLI:
6945 /* or $rt, $rt, $rb -> or33 for v3, v3m. */
6946 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
6947 && N32_IS_RB3 (insn))
6948 {
6949 if (N32_RT5 (insn) == N32_RA5 (insn))
6950 insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RB5 (insn));
6951 else if (N32_RT5 (insn) == N32_RB5 (insn))
6952 insn16 = N16_MISC33 (OR33, N32_RT5 (insn), N32_RA5 (insn));
6953 if (insn16)
6954 insn_type = NDS32_INSN_OR33;
6955 }
6956 break;
6957 case N32_ALU1_NOR:
6958 /* nor $rt, $ra, $ra -> not33 for v3, v3m. */
6959 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RB3 (insn)
6960 && N32_RA5 (insn) == N32_RB5 (insn))
6961 {
6962 insn16 = N16_MISC33 (NOT33, N32_RT5 (insn), N32_RA5 (insn));
6963 insn_type = NDS32_INSN_NOT33;
6964 }
6965 break;
6966 case N32_ALU1_SRAI:
6967 if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6968 {
6969 insn16 = N16_TYPE45 (SRAI45, N32_RT54 (insn), N32_UB5 (insn));
6970 insn_type = NDS32_INSN_SRAI45;
6971 }
6972 break;
6973
6974 case N32_ALU1_SRLI:
6975 if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn))
6976 {
6977 insn16 = N16_TYPE45 (SRLI45, N32_RT54 (insn), N32_UB5 (insn));
6978 insn_type = NDS32_INSN_SRLI45;
6979 }
6980 break;
6981
6982 case N32_ALU1_SLLI:
6983 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_UB5 (insn) < 8)
6984 {
6985 insn16 = N16_TYPE333 (SLLI333, N32_RT5 (insn), N32_RA5 (insn),
6986 N32_UB5 (insn));
6987 insn_type = NDS32_INSN_SLLI333;
6988 }
6989 break;
6990
6991 case N32_ALU1_ZEH:
6992 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
6993 {
6994 insn16 = N16_BFMI333 (ZEH33, N32_RT5 (insn), N32_RA5 (insn));
6995 insn_type = NDS32_INSN_ZEH33;
6996 }
6997 break;
6998
6999 case N32_ALU1_SEB:
7000 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7001 {
7002 insn16 = N16_BFMI333 (SEB33, N32_RT5 (insn), N32_RA5 (insn));
7003 insn_type = NDS32_INSN_SEB33;
7004 }
7005 break;
7006
7007 case N32_ALU1_SEH:
7008 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7009 {
7010 insn16 = N16_BFMI333 (SEH33, N32_RT5 (insn), N32_RA5 (insn));
7011 insn_type = NDS32_INSN_SEH33;
7012 }
7013 break;
7014
7015 case N32_ALU1_SLT:
7016 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7017 {
7018 /* Implicit r15. */
7019 insn16 = N16_TYPE45 (SLT45, N32_RA54 (insn), N32_RB5 (insn));
7020 insn_type = NDS32_INSN_SLT45;
7021 }
7022 break;
7023
7024 case N32_ALU1_SLTS:
7025 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn))
7026 {
7027 /* Implicit r15. */
7028 insn16 = N16_TYPE45 (SLTS45, N32_RA54 (insn), N32_RB5 (insn));
7029 insn_type = NDS32_INSN_SLTS45;
7030 }
7031 break;
7032 }
7033
7034 if ((insn16 & 0x8000) == 0)
7035 return 0;
7036
7037 if (pinsn16)
7038 *pinsn16 = insn16;
7039 if (pinsn_type)
7040 *pinsn_type = insn_type;
7041 return 1;
7042 }
7043
7044 static int
7045 nds32_convert_32_to_16_alu2 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7046 int *pinsn_type)
7047 {
7048 uint16_t insn16 = 0;
7049 int insn_type;
7050 unsigned long mach = bfd_get_mach (abfd);
7051
7052 /* TODO: bset, bclr, btgl, btst. */
7053 if (__GF (insn, 6, 4) != 0)
7054 return 0;
7055
7056 switch (N32_IMMU (insn, 6))
7057 {
7058 case N32_ALU2_MUL:
7059 if (mach >= MACH_V3 && N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7060 && N32_IS_RB3 (insn))
7061 {
7062 if (N32_RT5 (insn) == N32_RA5 (insn))
7063 insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RB5 (insn));
7064 else if (N32_RT5 (insn) == N32_RB5 (insn))
7065 insn16 = N16_MISC33 (MUL33, N32_RT5 (insn), N32_RA5 (insn));
7066 if (insn16)
7067 insn_type = NDS32_INSN_MUL33;
7068 }
7069 }
7070
7071 if ((insn16 & 0x8000) == 0)
7072 return 0;
7073
7074 if (pinsn16)
7075 *pinsn16 = insn16;
7076 if (pinsn_type)
7077 *pinsn_type = insn_type;
7078 return 1;
7079 }
7080
7081 int
7082 nds32_convert_32_to_16 (bfd *abfd, uint32_t insn, uint16_t *pinsn16,
7083 int *pinsn_type)
7084 {
7085 int op6;
7086 uint16_t insn16 = 0;
7087 int insn_type;
7088 unsigned long mach = bfd_get_mach (abfd);
7089
7090 /* Decode 32-bit instruction. */
7091 if (insn & 0x80000000)
7092 {
7093 /* Not 32-bit insn. */
7094 return 0;
7095 }
7096
7097 op6 = N32_OP6 (insn);
7098
7099 /* Convert it to 16-bit instruction. */
7100 switch (op6)
7101 {
7102 case N32_OP6_MOVI:
7103 if (IS_WITHIN_S (N32_IMM20S (insn), 5))
7104 {
7105 insn16 = N16_TYPE55 (MOVI55, N32_RT5 (insn), N32_IMM20S (insn));
7106 insn_type = NDS32_INSN_MOVI55;
7107 }
7108 else if (mach >= MACH_V3 && N32_IMM20S (insn) >= 16
7109 && N32_IMM20S (insn) < 48 && N32_IS_RT4 (insn))
7110 {
7111 insn16 = N16_TYPE45 (MOVPI45, N32_RT54 (insn),
7112 N32_IMM20S (insn) - 16);
7113 insn_type = NDS32_INSN_MOVPI45;
7114 }
7115 break;
7116
7117 case N32_OP6_ADDI:
7118 if (N32_IMM15S (insn) == 0)
7119 {
7120 /* Do not convert `addi $sp, $sp, 0' to `mov55 $sp, $sp',
7121 because `mov55 $sp, $sp' is ifret16 in V3 ISA. */
7122 if (mach <= MACH_V2
7123 || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7124 {
7125 insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7126 insn_type = NDS32_INSN_MOV55;
7127 }
7128 }
7129 else if (N32_IMM15S (insn) > 0)
7130 {
7131 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) < 8)
7132 {
7133 insn16 = N16_TYPE333 (ADDI333, N32_RT5 (insn), N32_RA5 (insn),
7134 N32_IMM15S (insn));
7135 insn_type = NDS32_INSN_ADDI333;
7136 }
7137 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7138 && N32_IMM15S (insn) < 32)
7139 {
7140 insn16 = N16_TYPE45 (ADDI45, N32_RT54 (insn), N32_IMM15S (insn));
7141 insn_type = NDS32_INSN_ADDI45;
7142 }
7143 else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7144 && N32_RT5 (insn) == N32_RA5 (insn)
7145 && N32_IMM15S (insn) < 512)
7146 {
7147 insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7148 insn_type = NDS32_INSN_ADDI10_SP;
7149 }
7150 else if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7151 && N32_RA5 (insn) == REG_SP && N32_IMM15S (insn) < 256
7152 && (N32_IMM15S (insn) % 4 == 0))
7153 {
7154 insn16 = N16_TYPE36 (ADDRI36_SP, N32_RT5 (insn),
7155 N32_IMM15S (insn) >> 2);
7156 insn_type = NDS32_INSN_ADDRI36_SP;
7157 }
7158 }
7159 else
7160 {
7161 /* Less than 0. */
7162 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn) && N32_IMM15S (insn) > -8)
7163 {
7164 insn16 = N16_TYPE333 (SUBI333, N32_RT5 (insn), N32_RA5 (insn),
7165 0 - N32_IMM15S (insn));
7166 insn_type = NDS32_INSN_SUBI333;
7167 }
7168 else if (N32_IS_RT4 (insn) && N32_RT5 (insn) == N32_RA5 (insn)
7169 && N32_IMM15S (insn) > -32)
7170 {
7171 insn16 = N16_TYPE45 (SUBI45, N32_RT54 (insn),
7172 0 - N32_IMM15S (insn));
7173 insn_type = NDS32_INSN_SUBI45;
7174 }
7175 else if (mach >= MACH_V2 && N32_RT5 (insn) == REG_SP
7176 && N32_RT5 (insn) == N32_RA5 (insn)
7177 && N32_IMM15S (insn) >= -512)
7178 {
7179 insn16 = N16_TYPE10 (ADDI10S, N32_IMM15S (insn));
7180 insn_type = NDS32_INSN_ADDI10_SP;
7181 }
7182 }
7183 break;
7184
7185 case N32_OP6_ORI:
7186 if (N32_IMM15S (insn) == 0)
7187 {
7188 /* Do not convert `ori $sp, $sp, 0' to `mov55 $sp, $sp',
7189 because `mov55 $sp, $sp' is ifret16 in V3 ISA. */
7190 if (mach <= MACH_V2
7191 || N32_RT5 (insn) != REG_SP || N32_RA5 (insn) != REG_SP)
7192 {
7193 insn16 = N16_TYPE55 (MOV55, N32_RT5 (insn), N32_RA5 (insn));
7194 insn_type = NDS32_INSN_MOV55;
7195 }
7196 }
7197 break;
7198
7199 case N32_OP6_SUBRI:
7200 if (mach >= MACH_V3 && N32_IS_RT3 (insn)
7201 && N32_IS_RA3 (insn) && N32_IMM15S (insn) == 0)
7202 {
7203 insn16 = N16_MISC33 (NEG33, N32_RT5 (insn), N32_RA5 (insn));
7204 insn_type = NDS32_INSN_NEG33;
7205 }
7206 break;
7207
7208 case N32_OP6_ANDI:
7209 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn))
7210 {
7211 if (N32_IMM15U (insn) == 1)
7212 {
7213 insn16 = N16_BFMI333 (XLSB33, N32_RT5 (insn), N32_RA5 (insn));
7214 insn_type = NDS32_INSN_XLSB33;
7215 }
7216 else if (N32_IMM15U (insn) == 0x7ff)
7217 {
7218 insn16 = N16_BFMI333 (X11B33, N32_RT5 (insn), N32_RA5 (insn));
7219 insn_type = NDS32_INSN_X11B33;
7220 }
7221 else if (N32_IMM15U (insn) == 0xff)
7222 {
7223 insn16 = N16_BFMI333 (ZEB33, N32_RT5 (insn), N32_RA5 (insn));
7224 insn_type = NDS32_INSN_ZEB33;
7225 }
7226 else if (mach >= MACH_V3 && N32_RT5 (insn) == N32_RA5 (insn)
7227 && N32_IMM15U (insn) < 256)
7228 {
7229 int imm15u = N32_IMM15U (insn);
7230
7231 if (__builtin_popcount (imm15u) == 1)
7232 {
7233 /* BMSKI33 */
7234 int imm3u = __builtin_ctz (imm15u);
7235
7236 insn16 = N16_BFMI333 (BMSKI33, N32_RT5 (insn), imm3u);
7237 insn_type = NDS32_INSN_BMSKI33;
7238 }
7239 else if (imm15u != 0 && __builtin_popcount (imm15u + 1) == 1)
7240 {
7241 /* FEXTI33 */
7242 int imm3u = __builtin_ctz (imm15u + 1) - 1;
7243
7244 insn16 = N16_BFMI333 (FEXTI33, N32_RT5 (insn), imm3u);
7245 insn_type = NDS32_INSN_FEXTI33;
7246 }
7247 }
7248 }
7249 break;
7250
7251 case N32_OP6_SLTI:
7252 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
7253 && IS_WITHIN_U (N32_IMM15S (insn), 5))
7254 {
7255 insn16 = N16_TYPE45 (SLTI45, N32_RA54 (insn), N32_IMM15S (insn));
7256 insn_type = NDS32_INSN_SLTI45;
7257 }
7258 break;
7259
7260 case N32_OP6_SLTSI:
7261 if (N32_RT5 (insn) == REG_R15 && N32_IS_RA4 (insn)
7262 && IS_WITHIN_U (N32_IMM15S (insn), 5))
7263 {
7264 insn16 = N16_TYPE45 (SLTSI45, N32_RA54 (insn), N32_IMM15S (insn));
7265 insn_type = NDS32_INSN_SLTSI45;
7266 }
7267 break;
7268
7269 case N32_OP6_LWI:
7270 if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
7271 {
7272 insn16 = N16_TYPE45 (LWI450, N32_RT54 (insn), N32_RA5 (insn));
7273 insn_type = NDS32_INSN_LWI450;
7274 }
7275 else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7276 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7277 {
7278 insn16 = N16_TYPE333 (LWI333, N32_RT5 (insn), N32_RA5 (insn),
7279 N32_IMM15S (insn));
7280 insn_type = NDS32_INSN_LWI333;
7281 }
7282 else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
7283 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7284 {
7285 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
7286 insn_type = NDS32_INSN_LWI37;
7287 }
7288 else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
7289 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7290 {
7291 insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 0, N32_IMM15S (insn));
7292 insn_type = NDS32_INSN_LWI37_SP;
7293 }
7294 else if (mach >= MACH_V2 && N32_IS_RT4 (insn) && N32_RA5 (insn) == REG_R8
7295 && -32 <= N32_IMM15S (insn) && N32_IMM15S (insn) < 0)
7296 {
7297 insn16 = N16_TYPE45 (LWI45_FE, N32_RT54 (insn),
7298 N32_IMM15S (insn) + 32);
7299 insn_type = NDS32_INSN_LWI45_FE;
7300 }
7301 break;
7302
7303 case N32_OP6_SWI:
7304 if (N32_IS_RT4 (insn) && N32_IMM15S (insn) == 0)
7305 {
7306 insn16 = N16_TYPE45 (SWI450, N32_RT54 (insn), N32_RA5 (insn));
7307 insn_type = NDS32_INSN_SWI450;
7308 }
7309 else if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7310 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7311 {
7312 insn16 = N16_TYPE333 (SWI333, N32_RT5 (insn), N32_RA5 (insn),
7313 N32_IMM15S (insn));
7314 insn_type = NDS32_INSN_SWI333;
7315 }
7316 else if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_FP
7317 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7318 {
7319 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
7320 insn_type = NDS32_INSN_SWI37;
7321 }
7322 else if (mach >= MACH_V2 && N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_SP
7323 && IS_WITHIN_U (N32_IMM15S (insn), 7))
7324 {
7325 insn16 = N16_TYPE37 (XWI37SP, N32_RT5 (insn), 1, N32_IMM15S (insn));
7326 insn_type = NDS32_INSN_SWI37_SP;
7327 }
7328 break;
7329
7330 case N32_OP6_LWI_BI:
7331 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7332 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7333 {
7334 insn16 = N16_TYPE333 (LWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
7335 N32_IMM15S (insn));
7336 insn_type = NDS32_INSN_LWI333_BI;
7337 }
7338 break;
7339
7340 case N32_OP6_SWI_BI:
7341 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7342 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7343 {
7344 insn16 = N16_TYPE333 (SWI333_BI, N32_RT5 (insn), N32_RA5 (insn),
7345 N32_IMM15S (insn));
7346 insn_type = NDS32_INSN_SWI333_BI;
7347 }
7348 break;
7349
7350 case N32_OP6_LHI:
7351 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7352 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7353 {
7354 insn16 = N16_TYPE333 (LHI333, N32_RT5 (insn), N32_RA5 (insn),
7355 N32_IMM15S (insn));
7356 insn_type = NDS32_INSN_LHI333;
7357 }
7358 break;
7359
7360 case N32_OP6_SHI:
7361 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7362 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7363 {
7364 insn16 = N16_TYPE333 (SHI333, N32_RT5 (insn), N32_RA5 (insn),
7365 N32_IMM15S (insn));
7366 insn_type = NDS32_INSN_SHI333;
7367 }
7368 break;
7369
7370 case N32_OP6_LBI:
7371 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7372 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7373 {
7374 insn16 = N16_TYPE333 (LBI333, N32_RT5 (insn), N32_RA5 (insn),
7375 N32_IMM15S (insn));
7376 insn_type = NDS32_INSN_LBI333;
7377 }
7378 break;
7379
7380 case N32_OP6_SBI:
7381 if (N32_IS_RT3 (insn) && N32_IS_RA3 (insn)
7382 && IS_WITHIN_U (N32_IMM15S (insn), 3))
7383 {
7384 insn16 = N16_TYPE333 (SBI333, N32_RT5 (insn), N32_RA5 (insn),
7385 N32_IMM15S (insn));
7386 insn_type = NDS32_INSN_SBI333;
7387 }
7388 break;
7389
7390 case N32_OP6_ALU1:
7391 return nds32_convert_32_to_16_alu1 (abfd, insn, pinsn16, pinsn_type);
7392
7393 case N32_OP6_ALU2:
7394 return nds32_convert_32_to_16_alu2 (abfd, insn, pinsn16, pinsn_type);
7395
7396 case N32_OP6_BR1:
7397 if (!IS_WITHIN_S (N32_IMM14S (insn), 8))
7398 goto done;
7399
7400 if ((insn & __BIT (14)) == 0)
7401 {
7402 /* N32_BR1_BEQ */
7403 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
7404 && N32_RT5 (insn) != REG_R5)
7405 insn16 = N16_TYPE38 (BEQS38, N32_RT5 (insn), N32_IMM14S (insn));
7406 else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
7407 && N32_RA5 (insn) != REG_R5)
7408 insn16 = N16_TYPE38 (BEQS38, N32_RA5 (insn), N32_IMM14S (insn));
7409 insn_type = NDS32_INSN_BEQS38;
7410 break;
7411 }
7412 else
7413 {
7414 /* N32_BR1_BNE */
7415 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5
7416 && N32_RT5 (insn) != REG_R5)
7417 insn16 = N16_TYPE38 (BNES38, N32_RT5 (insn), N32_IMM14S (insn));
7418 else if (N32_IS_RA3 (insn) && N32_RT5 (insn) == REG_R5
7419 && N32_RA5 (insn) != REG_R5)
7420 insn16 = N16_TYPE38 (BNES38, N32_RA5 (insn), N32_IMM14S (insn));
7421 insn_type = NDS32_INSN_BNES38;
7422 break;
7423 }
7424 break;
7425
7426 case N32_OP6_BR2:
7427 switch (N32_BR2_SUB (insn))
7428 {
7429 case N32_BR2_BEQZ:
7430 if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
7431 {
7432 insn16 = N16_TYPE38 (BEQZ38, N32_RT5 (insn), N32_IMM16S (insn));
7433 insn_type = NDS32_INSN_BEQZ38;
7434 }
7435 else if (N32_RT5 (insn) == REG_R15
7436 && IS_WITHIN_S (N32_IMM16S (insn), 8))
7437 {
7438 insn16 = N16_TYPE8 (BEQZS8, N32_IMM16S (insn));
7439 insn_type = NDS32_INSN_BEQZS8;
7440 }
7441 break;
7442
7443 case N32_BR2_BNEZ:
7444 if (N32_IS_RT3 (insn) && IS_WITHIN_S (N32_IMM16S (insn), 8))
7445 {
7446 insn16 = N16_TYPE38 (BNEZ38, N32_RT5 (insn), N32_IMM16S (insn));
7447 insn_type = NDS32_INSN_BNEZ38;
7448 }
7449 else if (N32_RT5 (insn) == REG_R15
7450 && IS_WITHIN_S (N32_IMM16S (insn), 8))
7451 {
7452 insn16 = N16_TYPE8 (BNEZS8, N32_IMM16S (insn));
7453 insn_type = NDS32_INSN_BNEZS8;
7454 }
7455 break;
7456
7457 case N32_BR2_IFCALL:
7458 if (IS_WITHIN_U (N32_IMM16S (insn), 9))
7459 {
7460 insn16 = N16_TYPE9 (IFCALL9, N32_IMM16S (insn));
7461 insn_type = NDS32_INSN_IFCALL9;
7462 }
7463 break;
7464 }
7465 break;
7466
7467 case N32_OP6_JI:
7468 if ((insn & __BIT (24)) == 0)
7469 {
7470 /* N32_JI_J */
7471 if (IS_WITHIN_S (N32_IMM24S (insn), 8))
7472 {
7473 insn16 = N16_TYPE8 (J8, N32_IMM24S (insn));
7474 insn_type = NDS32_INSN_J8;
7475 }
7476 }
7477 break;
7478
7479 case N32_OP6_JREG:
7480 if (__GF (insn, 8, 2) != 0)
7481 goto done;
7482
7483 switch (N32_IMMU (insn, 5))
7484 {
7485 case N32_JREG_JR:
7486 if (N32_JREG_HINT (insn) == 0)
7487 {
7488 /* jr */
7489 insn16 = N16_TYPE5 (JR5, N32_RB5 (insn));
7490 insn_type = NDS32_INSN_JR5;
7491 }
7492 else if (N32_JREG_HINT (insn) == 1)
7493 {
7494 /* ret */
7495 insn16 = N16_TYPE5 (RET5, N32_RB5 (insn));
7496 insn_type = NDS32_INSN_RET5;
7497 }
7498 else if (N32_JREG_HINT (insn) == 3)
7499 {
7500 /* ifret = mov55 $sp, $sp */
7501 insn16 = N16_TYPE55 (MOV55, REG_SP, REG_SP);
7502 insn_type = NDS32_INSN_IFRET;
7503 }
7504 break;
7505
7506 case N32_JREG_JRAL:
7507 /* It's convertible when return rt5 is $lp and address
7508 translation is kept. */
7509 if (N32_RT5 (insn) == REG_LP && N32_JREG_HINT (insn) == 0)
7510 {
7511 insn16 = N16_TYPE5 (JRAL5, N32_RB5 (insn));
7512 insn_type = NDS32_INSN_JRAL5;
7513 }
7514 break;
7515 }
7516 break;
7517
7518 case N32_OP6_MISC:
7519 if (N32_SUB5 (insn) == N32_MISC_BREAK && N32_SWID (insn) < 32)
7520 {
7521 /* For v3, swid above 31 are used for ex9.it. */
7522 insn16 = N16_TYPE5 (BREAK16, N32_SWID (insn));
7523 insn_type = NDS32_INSN_BREAK16;
7524 }
7525 break;
7526
7527 default:
7528 /* This instruction has no 16-bit variant. */
7529 goto done;
7530 }
7531
7532 done:
7533 /* Bit-15 of insn16 should be set for a valid instruction. */
7534 if ((insn16 & 0x8000) == 0)
7535 return 0;
7536
7537 if (pinsn16)
7538 *pinsn16 = insn16;
7539 if (pinsn_type)
7540 *pinsn_type = insn_type;
7541 return 1;
7542 }
7543
7544 static int
7545 special_convert_32_to_16 (unsigned long insn, uint16_t *pinsn16,
7546 Elf_Internal_Rela *reloc)
7547 {
7548 uint16_t insn16 = 0;
7549
7550 if ((reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG) == 0
7551 || (ELF32_R_TYPE (reloc->r_info) != R_NDS32_INSN16))
7552 return 0;
7553
7554 if (!N32_IS_RT3 (insn))
7555 return 0;
7556
7557 switch (N32_OP6 (insn))
7558 {
7559 case N32_OP6_LWI:
7560 if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
7561 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM15S (insn));
7562 break;
7563 case N32_OP6_SWI:
7564 if (N32_RA5 (insn) == REG_GP && IS_WITHIN_U (N32_IMM15S (insn), 7))
7565 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM15S (insn));
7566 break;
7567 case N32_OP6_HWGP:
7568 if (!IS_WITHIN_U (N32_IMM17S (insn), 7))
7569 break;
7570
7571 if (__GF (insn, 17, 3) == 6)
7572 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 0, N32_IMM17S (insn));
7573 else if (__GF (insn, 17, 3) == 7)
7574 insn16 = N16_TYPE37 (XWI37, N32_RT5 (insn), 1, N32_IMM17S (insn));
7575 break;
7576 }
7577
7578 if ((insn16 & 0x8000) == 0)
7579 return 0;
7580
7581 *pinsn16 = insn16;
7582 return 1;
7583 }
7584
7585 /* Convert a 16-bit instruction to 32-bit one.
7586 INSN16 it the input and PINSN it the point to output.
7587 Return non-zero on successful. Otherwise 0 is returned. */
7588
7589 int
7590 nds32_convert_16_to_32 (bfd *abfd, uint16_t insn16, uint32_t *pinsn)
7591 {
7592 uint32_t insn = 0xffffffff;
7593 unsigned long mach = bfd_get_mach (abfd);
7594
7595 /* NOTE: push25, pop25 and movd44 do not have 32-bit variants. */
7596
7597 switch (__GF (insn16, 9, 6))
7598 {
7599 case 0x4: /* add45 */
7600 insn = N32_ALU1 (ADD, N16_RT4 (insn16), N16_RT4 (insn16),
7601 N16_RA5 (insn16));
7602 goto done;
7603 case 0x5: /* sub45 */
7604 insn = N32_ALU1 (SUB, N16_RT4 (insn16), N16_RT4 (insn16),
7605 N16_RA5 (insn16));
7606 goto done;
7607 case 0x6: /* addi45 */
7608 insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
7609 N16_IMM5U (insn16));
7610 goto done;
7611 case 0x7: /* subi45 */
7612 insn = N32_TYPE2 (ADDI, N16_RT4 (insn16), N16_RT4 (insn16),
7613 -N16_IMM5U (insn16));
7614 goto done;
7615 case 0x8: /* srai45 */
7616 insn = N32_ALU1 (SRAI, N16_RT4 (insn16), N16_RT4 (insn16),
7617 N16_IMM5U (insn16));
7618 goto done;
7619 case 0x9: /* srli45 */
7620 insn = N32_ALU1 (SRLI, N16_RT4 (insn16), N16_RT4 (insn16),
7621 N16_IMM5U (insn16));
7622 goto done;
7623 case 0xa: /* slli333 */
7624 insn = N32_ALU1 (SLLI, N16_RT3 (insn16), N16_RA3 (insn16),
7625 N16_IMM3U (insn16));
7626 goto done;
7627 case 0xc: /* add333 */
7628 insn = N32_ALU1 (ADD, N16_RT3 (insn16), N16_RA3 (insn16),
7629 N16_RB3 (insn16));
7630 goto done;
7631 case 0xd: /* sub333 */
7632 insn = N32_ALU1 (SUB, N16_RT3 (insn16), N16_RA3 (insn16),
7633 N16_RB3 (insn16));
7634 goto done;
7635 case 0xe: /* addi333 */
7636 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
7637 N16_IMM3U (insn16));
7638 goto done;
7639 case 0xf: /* subi333 */
7640 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), N16_RA3 (insn16),
7641 -N16_IMM3U (insn16));
7642 goto done;
7643 case 0x10: /* lwi333 */
7644 insn = N32_TYPE2 (LWI, N16_RT3 (insn16), N16_RA3 (insn16),
7645 N16_IMM3U (insn16));
7646 goto done;
7647 case 0x12: /* lhi333 */
7648 insn = N32_TYPE2 (LHI, N16_RT3 (insn16), N16_RA3 (insn16),
7649 N16_IMM3U (insn16));
7650 goto done;
7651 case 0x13: /* lbi333 */
7652 insn = N32_TYPE2 (LBI, N16_RT3 (insn16), N16_RA3 (insn16),
7653 N16_IMM3U (insn16));
7654 goto done;
7655 case 0x11: /* lwi333.bi */
7656 insn = N32_TYPE2 (LWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
7657 N16_IMM3U (insn16));
7658 goto done;
7659 case 0x14: /* swi333 */
7660 insn = N32_TYPE2 (SWI, N16_RT3 (insn16), N16_RA3 (insn16),
7661 N16_IMM3U (insn16));
7662 goto done;
7663 case 0x16: /* shi333 */
7664 insn = N32_TYPE2 (SHI, N16_RT3 (insn16), N16_RA3 (insn16),
7665 N16_IMM3U (insn16));
7666 goto done;
7667 case 0x17: /* sbi333 */
7668 insn = N32_TYPE2 (SBI, N16_RT3 (insn16), N16_RA3 (insn16),
7669 N16_IMM3U (insn16));
7670 goto done;
7671 case 0x15: /* swi333.bi */
7672 insn = N32_TYPE2 (SWI_BI, N16_RT3 (insn16), N16_RA3 (insn16),
7673 N16_IMM3U (insn16));
7674 goto done;
7675 case 0x18: /* addri36.sp */
7676 insn = N32_TYPE2 (ADDI, N16_RT3 (insn16), REG_SP,
7677 N16_IMM6U (insn16) << 2);
7678 goto done;
7679 case 0x19: /* lwi45.fe */
7680 insn = N32_TYPE2 (LWI, N16_RT4 (insn16), REG_R8,
7681 (N16_IMM5U (insn16) - 32));
7682 goto done;
7683 case 0x1a: /* lwi450 */
7684 insn = N32_TYPE2 (LWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
7685 goto done;
7686 case 0x1b: /* swi450 */
7687 insn = N32_TYPE2 (SWI, N16_RT4 (insn16), N16_RA5 (insn16), 0);
7688 goto done;
7689
7690 /* These are r15 implied instructions. */
7691 case 0x30: /* slts45 */
7692 insn = N32_ALU1 (SLTS, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
7693 goto done;
7694 case 0x31: /* slt45 */
7695 insn = N32_ALU1 (SLT, REG_TA, N16_RT4 (insn16), N16_RA5 (insn16));
7696 goto done;
7697 case 0x32: /* sltsi45 */
7698 insn = N32_TYPE2 (SLTSI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
7699 goto done;
7700 case 0x33: /* slti45 */
7701 insn = N32_TYPE2 (SLTI, REG_TA, N16_RT4 (insn16), N16_IMM5U (insn16));
7702 goto done;
7703 case 0x34: /* beqzs8, bnezs8 */
7704 if (insn16 & __BIT (8))
7705 insn = N32_BR2 (BNEZ, REG_TA, N16_IMM8S (insn16));
7706 else
7707 insn = N32_BR2 (BEQZ, REG_TA, N16_IMM8S (insn16));
7708 goto done;
7709
7710 case 0x35: /* break16, ex9.it */
7711 /* Only consider range of v3 break16. */
7712 insn = N32_TYPE0 (MISC, (N16_IMM5U (insn16) << 5) | N32_MISC_BREAK);
7713 goto done;
7714
7715 case 0x3c: /* ifcall9 */
7716 insn = N32_BR2 (IFCALL, 0, N16_IMM9U (insn16));
7717 goto done;
7718 case 0x3d: /* movpi45 */
7719 insn = N32_TYPE1 (MOVI, N16_RT4 (insn16), N16_IMM5U (insn16) + 16);
7720 goto done;
7721
7722 case 0x3f: /* MISC33 */
7723 switch (insn16 & 0x7)
7724 {
7725 case 2: /* neg33 */
7726 insn = N32_TYPE2 (SUBRI, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7727 break;
7728 case 3: /* not33 */
7729 insn = N32_ALU1 (NOR, N16_RT3 (insn16), N16_RA3 (insn16),
7730 N16_RA3 (insn16));
7731 break;
7732 case 4: /* mul33 */
7733 insn = N32_ALU2 (MUL, N16_RT3 (insn16), N16_RT3 (insn16),
7734 N16_RA3 (insn16));
7735 break;
7736 case 5: /* xor33 */
7737 insn = N32_ALU1 (XOR, N16_RT3 (insn16), N16_RT3 (insn16),
7738 N16_RA3 (insn16));
7739 break;
7740 case 6: /* and33 */
7741 insn = N32_ALU1 (AND, N16_RT3 (insn16), N16_RT3 (insn16),
7742 N16_RA3 (insn16));
7743 break;
7744 case 7: /* or33 */
7745 insn = N32_ALU1 (OR, N16_RT3 (insn16), N16_RT3 (insn16),
7746 N16_RA3 (insn16));
7747 break;
7748 }
7749 goto done;
7750
7751 case 0xb:
7752 switch (insn16 & 0x7)
7753 {
7754 case 0: /* zeb33 */
7755 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0xff);
7756 break;
7757 case 1: /* zeh33 */
7758 insn = N32_ALU1 (ZEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7759 break;
7760 case 2: /* seb33 */
7761 insn = N32_ALU1 (SEB, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7762 break;
7763 case 3: /* seh33 */
7764 insn = N32_ALU1 (SEH, N16_RT3 (insn16), N16_RA3 (insn16), 0);
7765 break;
7766 case 4: /* xlsb33 */
7767 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 1);
7768 break;
7769 case 5: /* x11b33 */
7770 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RA3 (insn16), 0x7ff);
7771 break;
7772 case 6: /* bmski33 */
7773 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
7774 1 << __GF (insn16, 3, 3));
7775 break;
7776 case 7: /* fexti33 */
7777 insn = N32_TYPE2 (ANDI, N16_RT3 (insn16), N16_RT3 (insn16),
7778 (1 << (__GF (insn16, 3, 3) + 1)) - 1);
7779 break;
7780 }
7781 goto done;
7782 }
7783
7784 switch (__GF (insn16, 10, 5))
7785 {
7786 case 0x0: /* mov55 or ifret16 */
7787 if (mach >= MACH_V3 && N16_RT5 (insn16) == REG_SP
7788 && N16_RT5 (insn16) == N16_RA5 (insn16))
7789 insn = N32_JREG (JR, 0, 0, 0, 3);
7790 else
7791 insn = N32_TYPE2 (ADDI, N16_RT5 (insn16), N16_RA5 (insn16), 0);
7792 goto done;
7793 case 0x1: /* movi55 */
7794 insn = N32_TYPE1 (MOVI, N16_RT5 (insn16), N16_IMM5S (insn16));
7795 goto done;
7796 case 0x1b: /* addi10s (V2) */
7797 insn = N32_TYPE2 (ADDI, REG_SP, REG_SP, N16_IMM10S (insn16));
7798 goto done;
7799 }
7800
7801 switch (__GF (insn16, 11, 4))
7802 {
7803 case 0x7: /* lwi37.fp/swi37.fp */
7804 if (insn16 & __BIT (7)) /* swi37.fp */
7805 insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
7806 else /* lwi37.fp */
7807 insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_FP, N16_IMM7U (insn16));
7808 goto done;
7809 case 0x8: /* beqz38 */
7810 insn = N32_BR2 (BEQZ, N16_RT38 (insn16), N16_IMM8S (insn16));
7811 goto done;
7812 case 0x9: /* bnez38 */
7813 insn = N32_BR2 (BNEZ, N16_RT38 (insn16), N16_IMM8S (insn16));
7814 goto done;
7815 case 0xa: /* beqs38/j8, implied r5 */
7816 if (N16_RT38 (insn16) == 5)
7817 insn = N32_JI (J, N16_IMM8S (insn16));
7818 else
7819 insn = N32_BR1 (BEQ, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
7820 goto done;
7821 case 0xb: /* bnes38 and others */
7822 if (N16_RT38 (insn16) == 5)
7823 {
7824 switch (__GF (insn16, 5, 3))
7825 {
7826 case 0: /* jr5 */
7827 insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 0);
7828 break;
7829 case 4: /* ret5 */
7830 insn = N32_JREG (JR, 0, N16_RA5 (insn16), 0, 1);
7831 break;
7832 case 1: /* jral5 */
7833 insn = N32_JREG (JRAL, REG_LP, N16_RA5 (insn16), 0, 0);
7834 break;
7835 case 2: /* ex9.it imm5 */
7836 /* ex9.it had no 32-bit variantl. */
7837 break;
7838 case 5: /* add5.pc */
7839 /* add5.pc had no 32-bit variantl. */
7840 break;
7841 }
7842 }
7843 else /* bnes38 */
7844 insn = N32_BR1 (BNE, N16_RT38 (insn16), REG_R5, N16_IMM8S (insn16));
7845 goto done;
7846 case 0xe: /* lwi37/swi37 */
7847 if (insn16 & (1 << 7)) /* swi37.sp */
7848 insn = N32_TYPE2 (SWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
7849 else /* lwi37.sp */
7850 insn = N32_TYPE2 (LWI, N16_RT38 (insn16), REG_SP, N16_IMM7U (insn16));
7851 goto done;
7852 }
7853
7854 done:
7855 if (insn & 0x80000000)
7856 return 0;
7857
7858 if (pinsn)
7859 *pinsn = insn;
7860 return 1;
7861 }
7862 \f
7863 static bfd_boolean
7864 is_sda_access_insn (unsigned long insn)
7865 {
7866 switch (N32_OP6 (insn))
7867 {
7868 case N32_OP6_LWI:
7869 case N32_OP6_LHI:
7870 case N32_OP6_LHSI:
7871 case N32_OP6_LBI:
7872 case N32_OP6_LBSI:
7873 case N32_OP6_SWI:
7874 case N32_OP6_SHI:
7875 case N32_OP6_SBI:
7876 case N32_OP6_LWC:
7877 case N32_OP6_LDC:
7878 case N32_OP6_SWC:
7879 case N32_OP6_SDC:
7880 return TRUE;
7881 default:
7882 ;
7883 }
7884 return FALSE;
7885 }
7886
7887 static unsigned long
7888 turn_insn_to_sda_access (uint32_t insn, bfd_signed_vma type, uint32_t *pinsn)
7889 {
7890 uint32_t oinsn = 0;
7891
7892 switch (type)
7893 {
7894 case R_NDS32_GOT_LO12:
7895 case R_NDS32_GOTOFF_LO12:
7896 case R_NDS32_PLTREL_LO12:
7897 case R_NDS32_PLT_GOTREL_LO12:
7898 case R_NDS32_LO12S0_RELA:
7899 switch (N32_OP6 (insn))
7900 {
7901 case N32_OP6_LBI:
7902 /* lbi.gp */
7903 oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
7904 break;
7905 case N32_OP6_LBSI:
7906 /* lbsi.gp */
7907 oinsn = N32_TYPE1 (LBGP, N32_RT5 (insn), __BIT (19));
7908 break;
7909 case N32_OP6_SBI:
7910 /* sbi.gp */
7911 oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
7912 break;
7913 case N32_OP6_ORI:
7914 /* addi.gp */
7915 oinsn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
7916 break;
7917 }
7918 break;
7919
7920 case R_NDS32_LO12S1_RELA:
7921 switch (N32_OP6 (insn))
7922 {
7923 case N32_OP6_LHI:
7924 /* lhi.gp */
7925 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
7926 break;
7927 case N32_OP6_LHSI:
7928 /* lhsi.gp */
7929 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (18));
7930 break;
7931 case N32_OP6_SHI:
7932 /* shi.gp */
7933 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (19));
7934 break;
7935 }
7936 break;
7937
7938 case R_NDS32_LO12S2_RELA:
7939 switch (N32_OP6 (insn))
7940 {
7941 case N32_OP6_LWI:
7942 /* lwi.gp */
7943 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
7944 break;
7945 case N32_OP6_SWI:
7946 /* swi.gp */
7947 oinsn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
7948 break;
7949 }
7950 break;
7951
7952 case R_NDS32_LO12S2_DP_RELA:
7953 case R_NDS32_LO12S2_SP_RELA:
7954 oinsn = (insn & 0x7ff07000) | (REG_GP << 15);
7955 break;
7956 }
7957
7958 if (oinsn)
7959 *pinsn = oinsn;
7960
7961 return oinsn != 0;
7962 }
7963
7964 /* Linker hasn't found the correct merge section for non-section symbol
7965 in relax time, this work is left to the function elf_link_input_bfd().
7966 So for non-section symbol, _bfd_merged_section_offset is also needed
7967 to find the correct symbol address. */
7968
7969 static bfd_vma
7970 nds32_elf_rela_local_sym (bfd *abfd, Elf_Internal_Sym *sym,
7971 asection **psec, Elf_Internal_Rela *rel)
7972 {
7973 asection *sec = *psec;
7974 bfd_vma relocation;
7975
7976 relocation = (sec->output_section->vma
7977 + sec->output_offset + sym->st_value);
7978 if ((sec->flags & SEC_MERGE) && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
7979 {
7980 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
7981 rel->r_addend =
7982 _bfd_merged_section_offset (abfd, psec,
7983 elf_section_data (sec)->sec_info,
7984 sym->st_value + rel->r_addend);
7985 else
7986 rel->r_addend =
7987 _bfd_merged_section_offset (abfd, psec,
7988 elf_section_data (sec)->sec_info,
7989 sym->st_value) + rel->r_addend;
7990
7991 if (sec != *psec)
7992 {
7993 /* If we have changed the section, and our original section is
7994 marked with SEC_EXCLUDE, it means that the original
7995 SEC_MERGE section has been completely subsumed in some
7996 other SEC_MERGE section. In this case, we need to leave
7997 some info around for --emit-relocs. */
7998 if ((sec->flags & SEC_EXCLUDE) != 0)
7999 sec->kept_section = *psec;
8000 sec = *psec;
8001 }
8002 rel->r_addend -= relocation;
8003 rel->r_addend += sec->output_section->vma + sec->output_offset;
8004 }
8005 return relocation;
8006 }
8007
8008 static bfd_vma
8009 calculate_memory_address (bfd *abfd, Elf_Internal_Rela *irel,
8010 Elf_Internal_Sym *isymbuf,
8011 Elf_Internal_Shdr *symtab_hdr)
8012 {
8013 bfd_signed_vma foff;
8014 bfd_vma symval, addend;
8015 Elf_Internal_Rela irel_fn;
8016 Elf_Internal_Sym *isym;
8017 asection *sym_sec;
8018
8019 /* Get the value of the symbol referred to by the reloc. */
8020 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
8021 {
8022 /* A local symbol. */
8023 isym = isymbuf + ELF32_R_SYM (irel->r_info);
8024
8025 if (isym->st_shndx == SHN_UNDEF)
8026 sym_sec = bfd_und_section_ptr;
8027 else if (isym->st_shndx == SHN_ABS)
8028 sym_sec = bfd_abs_section_ptr;
8029 else if (isym->st_shndx == SHN_COMMON)
8030 sym_sec = bfd_com_section_ptr;
8031 else
8032 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
8033 memcpy (&irel_fn, irel, sizeof (Elf_Internal_Rela));
8034 symval = nds32_elf_rela_local_sym (abfd, isym, &sym_sec, &irel_fn);
8035 addend = irel_fn.r_addend;
8036 }
8037 else
8038 {
8039 unsigned long indx;
8040 struct elf_link_hash_entry *h;
8041
8042 /* An external symbol. */
8043 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
8044 h = elf_sym_hashes (abfd)[indx];
8045 BFD_ASSERT (h != NULL);
8046
8047 while (h->root.type == bfd_link_hash_indirect
8048 || h->root.type == bfd_link_hash_warning)
8049 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8050
8051 if (h->root.type != bfd_link_hash_defined
8052 && h->root.type != bfd_link_hash_defweak)
8053 /* This appears to be a reference to an undefined
8054 symbol. Just ignore it--it will be caught by the
8055 regular reloc processing. */
8056 return 0;
8057
8058 if (h->root.u.def.section->flags & SEC_MERGE)
8059 {
8060 sym_sec = h->root.u.def.section;
8061 symval = _bfd_merged_section_offset (abfd, &sym_sec, elf_section_data
8062 (sym_sec)->sec_info, h->root.u.def.value);
8063 symval = symval + sym_sec->output_section->vma
8064 + sym_sec->output_offset;
8065 }
8066 else
8067 symval = (h->root.u.def.value
8068 + h->root.u.def.section->output_section->vma
8069 + h->root.u.def.section->output_offset);
8070 addend = irel->r_addend;
8071 }
8072
8073 foff = symval + addend;
8074
8075 return foff;
8076 }
8077
8078 static bfd_vma
8079 calculate_got_memory_address (bfd *abfd, struct bfd_link_info *link_info,
8080 Elf_Internal_Rela *irel,
8081 Elf_Internal_Shdr *symtab_hdr)
8082 {
8083 int symndx;
8084 bfd_vma *local_got_offsets;
8085 /* Get the value of the symbol referred to by the reloc. */
8086 struct elf_link_hash_entry *h;
8087 struct elf_nds32_link_hash_table *htab = nds32_elf_hash_table (link_info);
8088
8089 /* An external symbol. */
8090 symndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
8091 h = elf_sym_hashes (abfd)[symndx];
8092 while (h->root.type == bfd_link_hash_indirect
8093 || h->root.type == bfd_link_hash_warning)
8094 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8095
8096 if (symndx >= 0)
8097 {
8098 BFD_ASSERT (h != NULL);
8099 return htab->sgot->output_section->vma + htab->sgot->output_offset
8100 + h->got.offset;
8101 }
8102 else
8103 {
8104 local_got_offsets = elf_local_got_offsets (abfd);
8105 BFD_ASSERT (local_got_offsets != NULL);
8106 return htab->sgot->output_section->vma + htab->sgot->output_offset
8107 + local_got_offsets[ELF32_R_SYM (irel->r_info)];
8108 }
8109
8110 /* The _GLOBAL_OFFSET_TABLE_ may be undefweak(or should be?). */
8111 /* The check of h->root.type is passed. */
8112 }
8113
8114 static int
8115 is_16bit_NOP (bfd *abfd ATTRIBUTE_UNUSED,
8116 asection *sec, Elf_Internal_Rela *rel)
8117 {
8118 bfd_byte *contents;
8119 unsigned short insn16;
8120
8121 if (!(rel->r_addend & R_NDS32_INSN16_CONVERT_FLAG))
8122 return FALSE;
8123 contents = elf_section_data (sec)->this_hdr.contents;
8124 insn16 = bfd_getb16 (contents + rel->r_offset);
8125 if (insn16 == NDS32_NOP16)
8126 return TRUE;
8127 return FALSE;
8128 }
8129
8130 /* It checks whether the instruction could be converted to
8131 16-bit form and returns the converted one.
8132
8133 `internal_relocs' is supposed to be sorted. */
8134
8135 static int
8136 is_convert_32_to_16 (bfd *abfd, asection *sec,
8137 Elf_Internal_Rela *reloc,
8138 Elf_Internal_Rela *internal_relocs,
8139 Elf_Internal_Rela *irelend,
8140 uint16_t *insn16)
8141 {
8142 #define NORMAL_32_TO_16 (1 << 0)
8143 #define SPECIAL_32_TO_16 (1 << 1)
8144 bfd_byte *contents = NULL;
8145 bfd_signed_vma off;
8146 bfd_vma mem_addr;
8147 uint32_t insn = 0;
8148 Elf_Internal_Rela *pc_rel;
8149 int pic_ext_target = 0;
8150 Elf_Internal_Shdr *symtab_hdr;
8151 Elf_Internal_Sym *isymbuf = NULL;
8152 int convert_type;
8153 bfd_vma offset;
8154
8155 if (reloc->r_offset + 4 > sec->size)
8156 return FALSE;
8157
8158 offset = reloc->r_offset;
8159
8160 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
8161 return FALSE;
8162 insn = bfd_getb32 (contents + offset);
8163
8164 if (nds32_convert_32_to_16 (abfd, insn, insn16, NULL))
8165 convert_type = NORMAL_32_TO_16;
8166 else if (special_convert_32_to_16 (insn, insn16, reloc))
8167 convert_type = SPECIAL_32_TO_16;
8168 else
8169 return FALSE;
8170
8171 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8172 if (!nds32_get_local_syms (abfd, sec, &isymbuf))
8173 return FALSE;
8174
8175 /* Find the first relocation of the same relocation-type,
8176 so we iteratie them forward. */
8177 pc_rel = reloc;
8178 while ((pc_rel - 1) >= internal_relocs && pc_rel[-1].r_offset == offset)
8179 pc_rel--;
8180
8181 for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8182 {
8183 if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8184 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8185 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA
8186 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8187 {
8188 off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr,
8189 &pic_ext_target);
8190 if (off >= ACCURATE_8BIT_S1 || off < -ACCURATE_8BIT_S1
8191 || off == 0)
8192 return FALSE;
8193 break;
8194 }
8195 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8196 {
8197 /* movi => movi55 */
8198 mem_addr = calculate_memory_address (abfd, pc_rel, isymbuf,
8199 symtab_hdr);
8200 /* mem_addr is unsigned, but the value should
8201 be between [-16, 15]. */
8202 if ((mem_addr + 0x10) >> 5)
8203 return FALSE;
8204 break;
8205 }
8206 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_20)
8207 || (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_TLS_LE_LO12))
8208 {
8209 /* It never happen movi to movi55 for R_NDS32_TLS_LE_20,
8210 because it can be relaxed to addi for TLS_LE_ADD. */
8211 return FALSE;
8212 }
8213 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8214 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8215 && (reloc->r_addend & R_NDS32_INSN16_FP7U2_FLAG)
8216 && convert_type == SPECIAL_32_TO_16)
8217 {
8218 /* fp-as-gp
8219 We've selected a best fp-base for this access, so we can
8220 always resolve it anyway. Do nothing. */
8221 break;
8222 }
8223 else if ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_NONE
8224 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_RELA_GNU_VTINHERIT))
8225 || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_RELA_GNU_VTENTRY)
8226 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_INSN16))
8227 || ((ELF32_R_TYPE (pc_rel->r_info) > R_NDS32_LOADSTORE)
8228 && (ELF32_R_TYPE (pc_rel->r_info) < R_NDS32_DWARF2_OP1_RELA)))
8229 {
8230 /* Prevent unresolved addi instruction translate
8231 to addi45 or addi333. */
8232 return FALSE;
8233 }
8234 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8235 {
8236 off = calculate_offset (abfd, sec, pc_rel, isymbuf, symtab_hdr,
8237 &pic_ext_target);
8238 if (off >= ACCURATE_U9BIT_S1 || off <= 0)
8239 return FALSE;
8240 break;
8241 }
8242 }
8243
8244 return TRUE;
8245 }
8246
8247 static void
8248 nds32_elf_write_16 (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *contents,
8249 Elf_Internal_Rela *reloc,
8250 Elf_Internal_Rela *internal_relocs,
8251 Elf_Internal_Rela *irelend,
8252 unsigned short insn16)
8253 {
8254 Elf_Internal_Rela *pc_rel;
8255 bfd_vma offset;
8256
8257 offset = reloc->r_offset;
8258 bfd_putb16 (insn16, contents + offset);
8259 /* Find the first relocation of the same relocation-type,
8260 so we iteratie them forward. */
8261 pc_rel = reloc;
8262 while ((pc_rel - 1) > internal_relocs && pc_rel[-1].r_offset == offset)
8263 pc_rel--;
8264
8265 for (; pc_rel < irelend && pc_rel->r_offset == offset; pc_rel++)
8266 {
8267 if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_15_PCREL_RELA
8268 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17_PCREL_RELA
8269 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PCREL_RELA)
8270 {
8271 pc_rel->r_info =
8272 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PCREL_RELA);
8273 }
8274 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_25_PLTREL)
8275 pc_rel->r_info =
8276 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_9_PLTREL);
8277 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_20_RELA)
8278 pc_rel->r_info =
8279 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_5_RELA);
8280 else if (ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA15S2_RELA
8281 || ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_SDA17S2_RELA)
8282 pc_rel->r_info =
8283 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_SDA_FP7U2_RELA);
8284 else if ((ELF32_R_TYPE (pc_rel->r_info) == R_NDS32_17IFC_PCREL_RELA))
8285 pc_rel->r_info =
8286 ELF32_R_INFO (ELF32_R_SYM (pc_rel->r_info), R_NDS32_10IFCU_PCREL_RELA);
8287 }
8288 }
8289
8290 /* Find a relocation of type specified by `reloc_type'
8291 of the same r_offset with reloc.
8292 If not found, return irelend.
8293
8294 Assuming relocations are sorted by r_offset,
8295 we find the relocation from `reloc' backward untill relocs,
8296 or find it from `reloc' forward untill irelend. */
8297
8298 static Elf_Internal_Rela *
8299 find_relocs_at_address (Elf_Internal_Rela *reloc,
8300 Elf_Internal_Rela *relocs,
8301 Elf_Internal_Rela *irelend,
8302 enum elf_nds32_reloc_type reloc_type)
8303 {
8304 Elf_Internal_Rela *rel_t;
8305
8306 /* Find backward. */
8307 for (rel_t = reloc;
8308 rel_t >= relocs && rel_t->r_offset == reloc->r_offset;
8309 rel_t--)
8310 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8311 return rel_t;
8312
8313 /* We didn't find it backward. Try find it forward. */
8314 for (rel_t = reloc;
8315 rel_t < irelend && rel_t->r_offset == reloc->r_offset;
8316 rel_t++)
8317 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8318 return rel_t;
8319
8320 return irelend;
8321 }
8322
8323 /* Find a relocation of specified type and offset.
8324 `reloc' is just a refence point to find a relocation at specified offset.
8325 If not found, return irelend.
8326
8327 Assuming relocations are sorted by r_offset,
8328 we find the relocation from `reloc' backward untill relocs,
8329 or find it from `reloc' forward untill irelend. */
8330
8331 static Elf_Internal_Rela *
8332 find_relocs_at_address_addr (Elf_Internal_Rela *reloc,
8333 Elf_Internal_Rela *relocs,
8334 Elf_Internal_Rela *irelend,
8335 enum elf_nds32_reloc_type reloc_type,
8336 bfd_vma offset_p)
8337 {
8338 Elf_Internal_Rela *rel_t = NULL;
8339
8340 /* First, we try to find a relocation of offset `offset_p',
8341 and then we use find_relocs_at_address to find specific type. */
8342
8343 if (reloc->r_offset > offset_p)
8344 {
8345 /* Find backward. */
8346 for (rel_t = reloc;
8347 rel_t >= relocs && rel_t->r_offset > offset_p; rel_t--)
8348 /* Do nothing. */;
8349 }
8350 else if (reloc->r_offset < offset_p)
8351 {
8352 /* Find forward. */
8353 for (rel_t = reloc;
8354 rel_t < irelend && rel_t->r_offset < offset_p; rel_t++)
8355 /* Do nothing. */;
8356 }
8357 else
8358 rel_t = reloc;
8359
8360 /* Not found? */
8361 if (rel_t < relocs || rel_t == irelend || rel_t->r_offset != offset_p)
8362 return irelend;
8363
8364 return find_relocs_at_address (rel_t, relocs, irelend, reloc_type);
8365 }
8366
8367 static bfd_boolean
8368 nds32_elf_check_dup_relocs (Elf_Internal_Rela *reloc,
8369 Elf_Internal_Rela *internal_relocs,
8370 Elf_Internal_Rela *irelend,
8371 unsigned char reloc_type)
8372 {
8373 Elf_Internal_Rela *rel_t;
8374
8375 for (rel_t = reloc;
8376 rel_t >= internal_relocs && rel_t->r_offset == reloc->r_offset;
8377 rel_t--)
8378 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8379 {
8380 if (ELF32_R_SYM (rel_t->r_info) == ELF32_R_SYM (reloc->r_info)
8381 && rel_t->r_addend == reloc->r_addend)
8382 continue;
8383 return TRUE;
8384 }
8385
8386 for (rel_t = reloc; rel_t < irelend && rel_t->r_offset == reloc->r_offset;
8387 rel_t++)
8388 if (ELF32_R_TYPE (rel_t->r_info) == reloc_type)
8389 {
8390 if (ELF32_R_SYM (rel_t->r_info) == ELF32_R_SYM (reloc->r_info)
8391 && rel_t->r_addend == reloc->r_addend)
8392 continue;
8393 return TRUE;
8394 }
8395
8396 return FALSE;
8397 }
8398
8399 typedef struct nds32_elf_blank nds32_elf_blank_t;
8400 struct nds32_elf_blank
8401 {
8402 /* Where the blank begins. */
8403 bfd_vma offset;
8404 /* The size of the blank. */
8405 bfd_vma size;
8406 /* The accumulative size before this blank. */
8407 bfd_vma total_size;
8408 nds32_elf_blank_t *next;
8409 nds32_elf_blank_t *prev;
8410 };
8411
8412 static nds32_elf_blank_t *blank_free_list = NULL;
8413
8414 static nds32_elf_blank_t *
8415 create_nds32_elf_blank (bfd_vma offset_p, bfd_vma size_p)
8416 {
8417 nds32_elf_blank_t *blank_t;
8418
8419 if (blank_free_list)
8420 {
8421 blank_t = blank_free_list;
8422 blank_free_list = blank_free_list->next;
8423 }
8424 else
8425 blank_t = bfd_malloc (sizeof (nds32_elf_blank_t));
8426
8427 if (blank_t == NULL)
8428 return NULL;
8429
8430 blank_t->offset = offset_p;
8431 blank_t->size = size_p;
8432 blank_t->total_size = 0;
8433 blank_t->next = NULL;
8434 blank_t->prev = NULL;
8435
8436 return blank_t;
8437 }
8438
8439 static void
8440 remove_nds32_elf_blank (nds32_elf_blank_t *blank_p)
8441 {
8442 if (blank_free_list)
8443 {
8444 blank_free_list->prev = blank_p;
8445 blank_p->next = blank_free_list;
8446 }
8447 else
8448 blank_p->next = NULL;
8449
8450 blank_p->prev = NULL;
8451 blank_free_list = blank_p;
8452 }
8453
8454 static void
8455 clean_nds32_elf_blank (void)
8456 {
8457 nds32_elf_blank_t *blank_t;
8458
8459 while (blank_free_list)
8460 {
8461 blank_t = blank_free_list;
8462 blank_free_list = blank_free_list->next;
8463 free (blank_t);
8464 }
8465 }
8466
8467 static nds32_elf_blank_t *
8468 search_nds32_elf_blank (nds32_elf_blank_t *blank_p, bfd_vma addr)
8469 {
8470 nds32_elf_blank_t *blank_t;
8471
8472 if (!blank_p)
8473 return NULL;
8474 blank_t = blank_p;
8475
8476 while (blank_t && addr < blank_t->offset)
8477 blank_t = blank_t->prev;
8478 while (blank_t && blank_t->next && addr >= blank_t->next->offset)
8479 blank_t = blank_t->next;
8480
8481 return blank_t;
8482 }
8483
8484 static bfd_vma
8485 get_nds32_elf_blank_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
8486 int overwrite)
8487 {
8488 nds32_elf_blank_t *blank_t;
8489
8490 blank_t = search_nds32_elf_blank (*blank_p, addr);
8491 if (!blank_t)
8492 return 0;
8493
8494 if (overwrite)
8495 *blank_p = blank_t;
8496
8497 if (addr < blank_t->offset + blank_t->size)
8498 return blank_t->total_size + (addr - blank_t->offset);
8499 else
8500 return blank_t->total_size + blank_t->size;
8501 }
8502
8503 static bfd_boolean
8504 insert_nds32_elf_blank (nds32_elf_blank_t **blank_p, bfd_vma addr, bfd_vma len)
8505 {
8506 nds32_elf_blank_t *blank_t, *blank_t2;
8507
8508 if (!*blank_p)
8509 {
8510 *blank_p = create_nds32_elf_blank (addr, len);
8511 return *blank_p ? TRUE : FALSE;
8512 }
8513
8514 blank_t = search_nds32_elf_blank (*blank_p, addr);
8515
8516 if (blank_t == NULL)
8517 {
8518 blank_t = create_nds32_elf_blank (addr, len);
8519 if (!blank_t)
8520 return FALSE;
8521 while ((*blank_p)->prev != NULL)
8522 *blank_p = (*blank_p)->prev;
8523 blank_t->next = *blank_p;
8524 (*blank_p)->prev = blank_t;
8525 (*blank_p) = blank_t;
8526 return TRUE;
8527 }
8528
8529 if (addr < blank_t->offset + blank_t->size)
8530 {
8531 if (addr > blank_t->offset + blank_t->size)
8532 blank_t->size = addr - blank_t->offset;
8533 }
8534 else
8535 {
8536 blank_t2 = create_nds32_elf_blank (addr, len);
8537 if (!blank_t2)
8538 return FALSE;
8539 if (blank_t->next)
8540 {
8541 blank_t->next->prev = blank_t2;
8542 blank_t2->next = blank_t->next;
8543 }
8544 blank_t2->prev = blank_t;
8545 blank_t->next = blank_t2;
8546 *blank_p = blank_t2;
8547 }
8548
8549 return TRUE;
8550 }
8551
8552 static bfd_boolean
8553 insert_nds32_elf_blank_recalc_total (nds32_elf_blank_t **blank_p, bfd_vma addr,
8554 bfd_vma len)
8555 {
8556 nds32_elf_blank_t *blank_t;
8557
8558 if (!insert_nds32_elf_blank (blank_p, addr, len))
8559 return FALSE;
8560
8561 blank_t = *blank_p;
8562
8563 if (!blank_t->prev)
8564 {
8565 blank_t->total_size = 0;
8566 blank_t = blank_t->next;
8567 }
8568
8569 while (blank_t)
8570 {
8571 blank_t->total_size = blank_t->prev->total_size + blank_t->prev->size;
8572 blank_t = blank_t->next;
8573 }
8574
8575 return TRUE;
8576 }
8577
8578 static void
8579 calc_nds32_blank_total (nds32_elf_blank_t *blank_p)
8580 {
8581 nds32_elf_blank_t *blank_t;
8582 bfd_vma total_size = 0;
8583
8584 if (!blank_p)
8585 return;
8586
8587 blank_t = blank_p;
8588 while (blank_t->prev)
8589 blank_t = blank_t->prev;
8590 while (blank_t)
8591 {
8592 blank_t->total_size = total_size;
8593 total_size += blank_t->size;
8594 blank_t = blank_t->next;
8595 }
8596 }
8597
8598 static bfd_boolean
8599 nds32_elf_relax_delete_blanks (bfd *abfd, asection *sec,
8600 nds32_elf_blank_t *blank_p)
8601 {
8602 Elf_Internal_Shdr *symtab_hdr; /* Symbol table header of this bfd. */
8603 Elf_Internal_Sym *isym = NULL; /* Symbol table of this bfd. */
8604 Elf_Internal_Sym *isymend; /* Symbol entry iterator. */
8605 unsigned int sec_shndx; /* The section the be relaxed. */
8606 bfd_byte *contents; /* Contents data of iterating section. */
8607 Elf_Internal_Rela *internal_relocs;
8608 Elf_Internal_Rela *irel;
8609 Elf_Internal_Rela *irelend;
8610 struct elf_link_hash_entry **sym_hashes;
8611 struct elf_link_hash_entry **end_hashes;
8612 unsigned int symcount;
8613 asection *sect;
8614 nds32_elf_blank_t *blank_t;
8615 nds32_elf_blank_t *blank_t2;
8616 nds32_elf_blank_t *blank_head;
8617
8618 blank_head = blank_t = blank_p;
8619 while (blank_head->prev != NULL)
8620 blank_head = blank_head->prev;
8621 while (blank_t->next != NULL)
8622 blank_t = blank_t->next;
8623
8624 if (blank_t->offset + blank_t->size <= sec->size)
8625 {
8626 blank_t->next = create_nds32_elf_blank (sec->size + 4, 0);
8627 blank_t->next->prev = blank_t;
8628 }
8629 if (blank_head->offset > 0)
8630 {
8631 blank_head->prev = create_nds32_elf_blank (0, 0);
8632 blank_head->prev->next = blank_head;
8633 blank_head = blank_head->prev;
8634 }
8635
8636 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
8637
8638 /* The deletion must stop at the next ALIGN reloc for an alignment
8639 power larger than the number of bytes we are deleting. */
8640
8641 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8642 if (!nds32_get_local_syms (abfd, sec, &isym))
8643 return FALSE;
8644
8645 if (isym == NULL)
8646 {
8647 isym = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8648 symtab_hdr->sh_info, 0, NULL, NULL, NULL);
8649 symtab_hdr->contents = (bfd_byte *) isym;
8650 }
8651
8652 if (isym == NULL || symtab_hdr->sh_info == 0)
8653 return FALSE;
8654
8655 blank_t = blank_head;
8656 calc_nds32_blank_total (blank_head);
8657
8658 for (sect = abfd->sections; sect != NULL; sect = sect->next)
8659 {
8660 /* Adjust all the relocs. */
8661
8662 /* Relocations MUST be kept in memory, because relaxation adjust them. */
8663 internal_relocs = _bfd_elf_link_read_relocs (abfd, sect, NULL, NULL,
8664 TRUE /* keep_memory */);
8665 irelend = internal_relocs + sect->reloc_count;
8666
8667 blank_t = blank_head;
8668 blank_t2 = blank_head;
8669
8670 if (!(sect->flags & SEC_RELOC))
8671 continue;
8672
8673 nds32_get_section_contents (abfd, sect, &contents, TRUE);
8674
8675 for (irel = internal_relocs; irel < irelend; irel++)
8676 {
8677 bfd_vma raddr;
8678
8679 if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_DIFF8
8680 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_DIFF32
8681 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
8682 {
8683 unsigned long val = 0;
8684 unsigned long mask;
8685 long before, between;
8686 long offset = 0;
8687
8688 switch (ELF32_R_TYPE (irel->r_info))
8689 {
8690 case R_NDS32_DIFF8:
8691 offset = bfd_get_8 (abfd, contents + irel->r_offset);
8692 break;
8693 case R_NDS32_DIFF16:
8694 offset = bfd_get_16 (abfd, contents + irel->r_offset);
8695 break;
8696 case R_NDS32_DIFF32:
8697 val = bfd_get_32 (abfd, contents + irel->r_offset);
8698 /* Get the signed bit and mask for the high part. The
8699 gcc will alarm when right shift 32-bit since the
8700 type size of long may be 32-bit. */
8701 mask = 0 - (val >> 31);
8702 if (mask)
8703 offset = (val | (mask - 0xffffffff));
8704 else
8705 offset = val;
8706 break;
8707 default:
8708 BFD_ASSERT (0);
8709 }
8710
8711 /* DIFF value
8712 0 |encoded in location|
8713 |------------|-------------------|---------
8714 sym+off(addend)
8715 -- before ---| *****************
8716 --------------------- between ---|
8717
8718 We only care how much data are relax between DIFF,
8719 marked as ***. */
8720
8721 before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
8722 between = get_nds32_elf_blank_total (&blank_t,
8723 irel->r_addend + offset, 0);
8724 if (between == before)
8725 goto done_adjust_diff;
8726
8727 switch (ELF32_R_TYPE (irel->r_info))
8728 {
8729 case R_NDS32_DIFF8:
8730 bfd_put_8 (abfd, offset - (between - before),
8731 contents + irel->r_offset);
8732 break;
8733 case R_NDS32_DIFF16:
8734 bfd_put_16 (abfd, offset - (between - before),
8735 contents + irel->r_offset);
8736 break;
8737 case R_NDS32_DIFF32:
8738 bfd_put_32 (abfd, offset - (between - before),
8739 contents + irel->r_offset);
8740 break;
8741 }
8742 }
8743 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_DIFF_ULEB128
8744 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx)
8745 {
8746 bfd_vma val = 0;
8747 unsigned int len = 0;
8748 unsigned long before, between;
8749 bfd_byte *endp, *p;
8750
8751 val = read_unsigned_leb128 (abfd, contents + irel->r_offset,
8752 &len);
8753
8754 before = get_nds32_elf_blank_total (&blank_t, irel->r_addend, 0);
8755 between = get_nds32_elf_blank_total (&blank_t,
8756 irel->r_addend + val, 0);
8757 if (between == before)
8758 goto done_adjust_diff;
8759
8760 p = contents + irel->r_offset;
8761 endp = p + len -1;
8762 memset (p, 0x80, len);
8763 *(endp) = 0;
8764 p = write_uleb128 (p, val - (between - before)) - 1;
8765 if (p < endp)
8766 *p |= 0x80;
8767 }
8768 done_adjust_diff:
8769
8770 if (sec == sect)
8771 {
8772 raddr = irel->r_offset;
8773 irel->r_offset -= get_nds32_elf_blank_total (&blank_t2,
8774 irel->r_offset, 1);
8775
8776 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
8777 continue;
8778 if (blank_t2 && blank_t2->next
8779 && (blank_t2->offset > raddr
8780 || blank_t2->next->offset <= raddr))
8781 _bfd_error_handler
8782 (_("%B: %s\n"), abfd,
8783 "Error: search_nds32_elf_blank reports wrong node");
8784
8785 /* Mark reloc in deleted portion as NONE.
8786 For some relocs like R_NDS32_LABEL that doesn't modify the
8787 content in the section. R_NDS32_LABEL doesn't belong to the
8788 instruction in the section, so we should preserve it. */
8789 if (raddr >= blank_t2->offset
8790 && raddr < blank_t2->offset + blank_t2->size
8791 && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL
8792 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_BEGIN
8793 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
8794 && ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
8795 && ELF32_R_TYPE (irel->r_info) != R_NDS32_SUBTRAHEND
8796 && ELF32_R_TYPE (irel->r_info) != R_NDS32_MINUEND)
8797 {
8798 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
8799 R_NDS32_NONE);
8800 continue;
8801 }
8802 }
8803
8804 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE
8805 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
8806 || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
8807 continue;
8808
8809 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info
8810 && isym[ELF32_R_SYM (irel->r_info)].st_shndx == sec_shndx
8811 && ELF_ST_TYPE (isym[ELF32_R_SYM (irel->r_info)].st_info) == STT_SECTION)
8812 {
8813 if (irel->r_addend <= sec->size)
8814 irel->r_addend -=
8815 get_nds32_elf_blank_total (&blank_t, irel->r_addend, 1);
8816 }
8817 }
8818 }
8819
8820 /* Adjust the local symbols defined in this section. */
8821 blank_t = blank_head;
8822 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
8823 {
8824 if (isym->st_shndx == sec_shndx)
8825 {
8826 if (isym->st_value <= sec->size)
8827 {
8828 bfd_vma ahead;
8829 bfd_vma orig_addr = isym->st_value;
8830
8831 ahead = get_nds32_elf_blank_total (&blank_t, isym->st_value, 1);
8832 isym->st_value -= ahead;
8833
8834 /* Adjust function size. */
8835 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC
8836 && isym->st_size > 0)
8837 isym->st_size -=
8838 get_nds32_elf_blank_total
8839 (&blank_t, orig_addr + isym->st_size, 0) - ahead;
8840 }
8841 }
8842 }
8843
8844 /* Now adjust the global symbols defined in this section. */
8845 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
8846 - symtab_hdr->sh_info);
8847 sym_hashes = elf_sym_hashes (abfd);
8848 end_hashes = sym_hashes + symcount;
8849 blank_t = blank_head;
8850 for (; sym_hashes < end_hashes; sym_hashes++)
8851 {
8852 struct elf_link_hash_entry *sym_hash = *sym_hashes;
8853
8854 if ((sym_hash->root.type == bfd_link_hash_defined
8855 || sym_hash->root.type == bfd_link_hash_defweak)
8856 && sym_hash->root.u.def.section == sec)
8857 {
8858 if (sym_hash->root.u.def.value <= sec->size)
8859 {
8860 bfd_vma ahead;
8861 bfd_vma orig_addr = sym_hash->root.u.def.value;
8862
8863 ahead = get_nds32_elf_blank_total (&blank_t, sym_hash->root.u.def.value, 1);
8864 sym_hash->root.u.def.value -= ahead;
8865
8866 /* Adjust function size. */
8867 if (sym_hash->type == STT_FUNC)
8868 sym_hash->size -=
8869 get_nds32_elf_blank_total
8870 (&blank_t, orig_addr + sym_hash->size, 0) - ahead;
8871
8872 }
8873 }
8874 }
8875
8876 contents = elf_section_data (sec)->this_hdr.contents;
8877 blank_t = blank_head;
8878 while (blank_t->next)
8879 {
8880 /* Actually delete the bytes. */
8881
8882 /* If current blank is the last blank overlap with current section,
8883 go to finish process. */
8884 if (sec->size <= (blank_t->next->offset))
8885 break;
8886
8887 memmove (contents + blank_t->offset - blank_t->total_size,
8888 contents + blank_t->offset + blank_t->size,
8889 blank_t->next->offset - (blank_t->offset + blank_t->size));
8890
8891 blank_t = blank_t->next;
8892 }
8893
8894 if (sec->size > (blank_t->offset + blank_t->size))
8895 {
8896 /* There are remaining code between blank and section boundary.
8897 Move the remaining code to appropriate location. */
8898 memmove (contents + blank_t->offset - blank_t->total_size,
8899 contents + blank_t->offset + blank_t->size,
8900 sec->size - (blank_t->offset + blank_t->size));
8901 sec->size -= blank_t->total_size + blank_t->size;
8902 }
8903 else
8904 /* This blank is not entirely included in the section,
8905 reduce the section size by only part of the blank size. */
8906 sec->size -= blank_t->total_size + (sec->size - blank_t->offset);
8907
8908 while (blank_head)
8909 {
8910 blank_t = blank_head;
8911 blank_head = blank_head->next;
8912 remove_nds32_elf_blank (blank_t);
8913 }
8914
8915 return TRUE;
8916 }
8917
8918 /* Get the contents of a section. */
8919
8920 static int
8921 nds32_get_section_contents (bfd *abfd, asection *sec,
8922 bfd_byte **contents_p, bfd_boolean cache)
8923 {
8924 /* Get the section contents. */
8925 if (elf_section_data (sec)->this_hdr.contents != NULL)
8926 *contents_p = elf_section_data (sec)->this_hdr.contents;
8927 else
8928 {
8929 if (!bfd_malloc_and_get_section (abfd, sec, contents_p))
8930 return FALSE;
8931 if (cache)
8932 elf_section_data (sec)->this_hdr.contents = *contents_p;
8933 }
8934
8935 return TRUE;
8936 }
8937
8938 /* Get the contents of the internal symbol of abfd. */
8939
8940 static int
8941 nds32_get_local_syms (bfd *abfd, asection *sec ATTRIBUTE_UNUSED,
8942 Elf_Internal_Sym **isymbuf_p)
8943 {
8944 Elf_Internal_Shdr *symtab_hdr;
8945 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8946
8947 /* Read this BFD's local symbols if we haven't done so already. */
8948 if (*isymbuf_p == NULL && symtab_hdr->sh_info != 0)
8949 {
8950 *isymbuf_p = (Elf_Internal_Sym *) symtab_hdr->contents;
8951 if (*isymbuf_p == NULL)
8952 {
8953 *isymbuf_p = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8954 symtab_hdr->sh_info, 0,
8955 NULL, NULL, NULL);
8956 if (*isymbuf_p == NULL)
8957 return FALSE;
8958 }
8959 }
8960 symtab_hdr->contents = (bfd_byte *) (*isymbuf_p);
8961
8962 return TRUE;
8963 }
8964
8965 /* Range of small data. */
8966 static bfd_vma sdata_range[2][2];
8967 static bfd_vma const sdata_init_range[2] =
8968 { ACCURATE_12BIT_S1, ACCURATE_19BIT };
8969
8970 static int
8971 nds32_elf_insn_size (bfd *abfd ATTRIBUTE_UNUSED,
8972 bfd_byte *contents, bfd_vma addr)
8973 {
8974 unsigned long insn = bfd_getb32 (contents + addr);
8975
8976 if (insn & 0x80000000)
8977 return 2;
8978
8979 return 4;
8980 }
8981
8982 /* Set the gp relax range. We have to measure the safe range
8983 to do gp relaxation. */
8984
8985 static void
8986 relax_range_measurement (bfd *abfd)
8987 {
8988 asection *sec_f, *sec_b;
8989 /* For upper bound. */
8990 bfd_vma maxpgsz = get_elf_backend_data (abfd)->maxpagesize;
8991 bfd_vma align;
8992 static int decide_relax_range = 0;
8993 int i;
8994 int range_number = sizeof (sdata_init_range) / sizeof (sdata_init_range[0]);
8995
8996 if (decide_relax_range)
8997 return;
8998 decide_relax_range = 1;
8999
9000 if (sda_rela_sec == NULL)
9001 {
9002 /* Since there is no data sections, we assume the range is page size. */
9003 for (i = 0; i < range_number; i++)
9004 {
9005 sdata_range[i][0] = sdata_init_range[i] - 0x1000;
9006 sdata_range[i][1] = sdata_init_range[i] - 0x1000;
9007 }
9008 return;
9009 }
9010
9011 /* Get the biggest alignment power after the gp located section. */
9012 sec_f = sda_rela_sec->output_section;
9013 sec_b = sec_f->next;
9014 align = 0;
9015 while (sec_b != NULL)
9016 {
9017 if ((unsigned)(1 << sec_b->alignment_power) > align)
9018 align = (1 << sec_b->alignment_power);
9019 sec_b = sec_b->next;
9020 }
9021
9022 /* I guess we can not determine the section before
9023 gp located section, so we assume the align is max page size. */
9024 for (i = 0; i < range_number; i++)
9025 {
9026 sdata_range[i][1] = sdata_init_range[i] - align;
9027 BFD_ASSERT (sdata_range[i][1] <= sdata_init_range[i]);
9028 sdata_range[i][0] = sdata_init_range[i] - maxpgsz;
9029 BFD_ASSERT (sdata_range[i][0] <= sdata_init_range[i]);
9030 }
9031 }
9032
9033 /* These are macros used to check flags encoded in r_addend.
9034 They are only used by nds32_elf_relax_section (). */
9035 #define GET_SEQ_LEN(addend) ((addend) & 0x000000ff)
9036 #define IS_1ST_CONVERT(addend) ((addend) & 0x80000000)
9037 #define IS_OPTIMIZE(addend) ((addend) & 0x40000000)
9038 #define IS_16BIT_ON(addend) ((addend) & 0x20000000)
9039
9040 /* Relax LONGCALL1 relocation for nds32_elf_relax_section. */
9041
9042 static bfd_boolean
9043 nds32_elf_relax_longcall1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9044 Elf_Internal_Rela *internal_relocs, int *insn_len,
9045 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9046 Elf_Internal_Shdr *symtab_hdr)
9047 {
9048 /* There are 3 variations for LONGCALL1
9049 case 4-4-2; 16-bit on, optimize off or optimize for space
9050 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9051 ori ta, ta, lo12(symbol) ; LO12S0
9052 jral5 ta ;
9053
9054 case 4-4-4; 16-bit off, optimize don't care
9055 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9056 ori ta, ta, lo12(symbol) ; LO12S0
9057 jral ta ;
9058
9059 case 4-4-4; 16-bit on, optimize for speed
9060 sethi ta, hi20(symbol) ; LONGCALL1/HI20
9061 ori ta, ta, lo12(symbol) ; LO12S0
9062 jral ta ;
9063 Check code for -mlong-calls output. */
9064
9065 /* Get the reloc for the address from which the register is
9066 being loaded. This reloc will tell us which function is
9067 actually being called. */
9068
9069 bfd_vma laddr;
9070 int seq_len; /* Original length of instruction sequence. */
9071 uint32_t insn;
9072 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9073 int pic_ext_target = 0;
9074 bfd_signed_vma foff;
9075 uint16_t insn16;
9076
9077 irelend = internal_relocs + sec->reloc_count;
9078 seq_len = GET_SEQ_LEN (irel->r_addend);
9079 laddr = irel->r_offset;
9080 *insn_len = seq_len;
9081
9082 hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9083 R_NDS32_HI20_RELA, laddr);
9084 lo_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9085 R_NDS32_LO12S0_ORI_RELA,
9086 laddr + 4);
9087
9088 if (hi_irelfn == irelend || lo_irelfn == irelend)
9089 {
9090 _bfd_error_handler
9091 ("%B: warning: R_NDS32_LONGCALL1 points to unrecognized"
9092 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9093 return FALSE;
9094 }
9095
9096 /* Get the value of the symbol referred to by the reloc. */
9097 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9098 &pic_ext_target);
9099
9100 /* This condition only happened when symbol is undefined. */
9101 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9102 || foff >= CONSERVATIVE_24BIT_S1)
9103 return FALSE;
9104
9105 /* Relax to: jal symbol; 25_PCREL */
9106 /* For simplicity of coding, we are going to modify the section
9107 contents, the section relocs, and the BFD symbol table. We
9108 must tell the rest of the code not to free up this
9109 information. It would be possible to instead create a table
9110 of changes which have to be made, as is done in coff-mips.c;
9111 that would be more work, but would require less memory when
9112 the linker is run. */
9113
9114 /* Replace the long call with a jal. */
9115 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9116 R_NDS32_25_PCREL_RELA);
9117 irel->r_addend = hi_irelfn->r_addend;
9118
9119 /* We don't resolve this here but resolve it in relocate_section. */
9120 insn = INSN_JAL;
9121 bfd_putb32 (insn, contents + irel->r_offset);
9122
9123 hi_irelfn->r_info =
9124 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9125 lo_irelfn->r_info =
9126 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9127 *insn_len = 4;
9128
9129 if (seq_len & 0x2)
9130 {
9131 insn16 = NDS32_NOP16;
9132 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9133 lo_irelfn->r_info =
9134 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9135 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9136 *insn_len += 2;
9137 }
9138 return TRUE;
9139 }
9140
9141 #define CONVERT_CONDITION_CALL(insn) (((insn) & 0xffff0000) ^ 0x90000)
9142 /* Relax LONGCALL2 relocation for nds32_elf_relax_section. */
9143
9144 static bfd_boolean
9145 nds32_elf_relax_longcall2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9146 Elf_Internal_Rela *internal_relocs, int *insn_len,
9147 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9148 Elf_Internal_Shdr *symtab_hdr)
9149 {
9150 /* bltz rt, .L1 ; LONGCALL2
9151 jal symbol ; 25_PCREL
9152 .L1: */
9153
9154 /* Get the reloc for the address from which the register is
9155 being loaded. This reloc will tell us which function is
9156 actually being called. */
9157
9158 bfd_vma laddr;
9159 uint32_t insn;
9160 Elf_Internal_Rela *i1_irelfn, *cond_irelfn, *irelend;
9161 int pic_ext_target = 0;
9162 bfd_signed_vma foff;
9163
9164 irelend = internal_relocs + sec->reloc_count;
9165 laddr = irel->r_offset;
9166 i1_irelfn =
9167 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9168 R_NDS32_25_PCREL_RELA, laddr + 4);
9169
9170 if (i1_irelfn == irelend)
9171 {
9172 _bfd_error_handler
9173 ("%B: warning: R_NDS32_LONGCALL2 points to unrecognized"
9174 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9175 return FALSE;
9176 }
9177
9178 insn = bfd_getb32 (contents + laddr);
9179
9180 /* Get the value of the symbol referred to by the reloc. */
9181 foff = calculate_offset (abfd, sec, i1_irelfn, isymbuf, symtab_hdr,
9182 &pic_ext_target);
9183
9184 if (foff == 0 || foff < -CONSERVATIVE_16BIT_S1
9185 || foff >= CONSERVATIVE_16BIT_S1)
9186 return FALSE;
9187
9188 /* Relax to bgezal rt, label ; 17_PCREL
9189 or bltzal rt, label ; 17_PCREL */
9190
9191 /* Convert to complimentary conditional call. */
9192 insn = CONVERT_CONDITION_CALL (insn);
9193
9194 /* For simplicity of coding, we are going to modify the section
9195 contents, the section relocs, and the BFD symbol table. We
9196 must tell the rest of the code not to free up this
9197 information. It would be possible to instead create a table
9198 of changes which have to be made, as is done in coff-mips.c;
9199 that would be more work, but would require less memory when
9200 the linker is run. */
9201
9202 /* Clean unnessary relocations. */
9203 i1_irelfn->r_info =
9204 ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info), R_NDS32_NONE);
9205 cond_irelfn =
9206 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9207 R_NDS32_17_PCREL_RELA, laddr);
9208 if (cond_irelfn != irelend)
9209 cond_irelfn->r_info =
9210 ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info), R_NDS32_NONE);
9211
9212 /* Replace the long call with a bgezal. */
9213 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i1_irelfn->r_info),
9214 R_NDS32_17_PCREL_RELA);
9215 irel->r_addend = i1_irelfn->r_addend;
9216
9217 bfd_putb32 (insn, contents + irel->r_offset);
9218
9219 *insn_len = 4;
9220 return TRUE;
9221 }
9222
9223 /* Relax LONGCALL3 relocation for nds32_elf_relax_section. */
9224
9225 static bfd_boolean
9226 nds32_elf_relax_longcall3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9227 Elf_Internal_Rela *internal_relocs, int *insn_len,
9228 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9229 Elf_Internal_Shdr *symtab_hdr)
9230 {
9231 /* There are 3 variations for LONGCALL3
9232 case 4-4-4-2; 16-bit on, optimize off or optimize for space
9233 bltz rt, $1 ; LONGCALL3
9234 sethi ta, hi20(symbol) ; HI20
9235 ori ta, ta, lo12(symbol) ; LO12S0
9236 jral5 ta ;
9237 $1
9238
9239 case 4-4-4-4; 16-bit off, optimize don't care
9240 bltz rt, $1 ; LONGCALL3
9241 sethi ta, hi20(symbol) ; HI20
9242 ori ta, ta, lo12(symbol) ; LO12S0
9243 jral ta ;
9244 $1
9245
9246 case 4-4-4-4; 16-bit on, optimize for speed
9247 bltz rt, $1 ; LONGCALL3
9248 sethi ta, hi20(symbol) ; HI20
9249 ori ta, ta, lo12(symbol) ; LO12S0
9250 jral ta ;
9251 $1 */
9252
9253 /* Get the reloc for the address from which the register is
9254 being loaded. This reloc will tell us which function is
9255 actually being called. */
9256
9257 bfd_vma laddr;
9258 int seq_len; /* Original length of instruction sequence. */
9259 uint32_t insn;
9260 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9261 int pic_ext_target = 0;
9262 bfd_signed_vma foff;
9263 uint16_t insn16;
9264
9265 irelend = internal_relocs + sec->reloc_count;
9266 seq_len = GET_SEQ_LEN (irel->r_addend);
9267 laddr = irel->r_offset;
9268 *insn_len = seq_len;
9269
9270 hi_irelfn =
9271 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9272 R_NDS32_HI20_RELA, laddr + 4);
9273 lo_irelfn =
9274 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9275 R_NDS32_LO12S0_ORI_RELA, laddr + 8);
9276
9277 if (hi_irelfn == irelend || lo_irelfn == irelend)
9278 {
9279 _bfd_error_handler
9280 ("%B: warning: R_NDS32_LONGCALL3 points to unrecognized"
9281 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9282 return FALSE;
9283 }
9284
9285 /* Get the value of the symbol referred to by the reloc. */
9286 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9287 &pic_ext_target);
9288
9289 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9290 || foff >= CONSERVATIVE_24BIT_S1)
9291 return FALSE;
9292
9293 insn = bfd_getb32 (contents + laddr);
9294 if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
9295 {
9296 /* Relax to bgezal rt, label ; 17_PCREL
9297 or bltzal rt, label ; 17_PCREL */
9298
9299 /* Convert to complimentary conditional call. */
9300 insn = CONVERT_CONDITION_CALL (insn);
9301 bfd_putb32 (insn, contents + irel->r_offset);
9302
9303 *insn_len = 4;
9304 irel->r_info =
9305 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9306 hi_irelfn->r_info =
9307 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
9308 lo_irelfn->r_info =
9309 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9310
9311 cond_irelfn =
9312 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9313 R_NDS32_17_PCREL_RELA, laddr);
9314 if (cond_irelfn != irelend)
9315 {
9316 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9317 R_NDS32_17_PCREL_RELA);
9318 cond_irelfn->r_addend = hi_irelfn->r_addend;
9319 }
9320
9321 if (seq_len & 0x2)
9322 {
9323 insn16 = NDS32_NOP16;
9324 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9325 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9326 R_NDS32_INSN16);
9327 hi_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9328 insn_len += 2;
9329 }
9330 }
9331 else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
9332 {
9333 /* Relax to the following instruction sequence
9334 bltz rt, $1 ; LONGCALL2
9335 jal symbol ; 25_PCREL
9336 $1 */
9337 *insn_len = 8;
9338 insn = INSN_JAL;
9339 bfd_putb32 (insn, contents + hi_irelfn->r_offset);
9340
9341 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9342 R_NDS32_25_PCREL_RELA);
9343 irel->r_info =
9344 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL2);
9345
9346 lo_irelfn->r_info =
9347 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9348
9349 if (seq_len & 0x2)
9350 {
9351 insn16 = NDS32_NOP16;
9352 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9353 lo_irelfn->r_info =
9354 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_INSN16);
9355 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9356 insn_len += 2;
9357 }
9358 }
9359 return TRUE;
9360 }
9361
9362 /* Relax LONGJUMP1 relocation for nds32_elf_relax_section. */
9363
9364 static bfd_boolean
9365 nds32_elf_relax_longjump1 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9366 Elf_Internal_Rela *internal_relocs, int *insn_len,
9367 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9368 Elf_Internal_Shdr *symtab_hdr)
9369 {
9370 /* There are 3 variations for LONGJUMP1
9371 case 4-4-2; 16-bit bit on, optimize off or optimize for space
9372 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
9373 ori ta, ta, lo12(symbol) ; LO12S0
9374 jr5 ta ;
9375
9376 case 4-4-4; 16-bit off, optimize don't care
9377 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
9378 ori ta, ta, lo12(symbol) ; LO12S0
9379 jr ta ;
9380
9381 case 4-4-4; 16-bit on, optimize for speed
9382 sethi ta, hi20(symbol) ; LONGJUMP1/HI20
9383 ori ta, ta, lo12(symbol) ; LO12S0
9384 jr ta ; */
9385
9386 /* Get the reloc for the address from which the register is
9387 being loaded. This reloc will tell us which function is
9388 actually being called. */
9389
9390 bfd_vma laddr;
9391 int seq_len; /* Original length of instruction sequence. */
9392 int insn16_on; /* 16-bit on/off. */
9393 uint32_t insn;
9394 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *irelend;
9395 int pic_ext_target = 0;
9396 bfd_signed_vma foff;
9397 uint16_t insn16;
9398 unsigned long reloc;
9399
9400 irelend = internal_relocs + sec->reloc_count;
9401 seq_len = GET_SEQ_LEN (irel->r_addend);
9402 laddr = irel->r_offset;
9403 *insn_len = seq_len;
9404 insn16_on = IS_16BIT_ON (irel->r_addend);
9405
9406 hi_irelfn =
9407 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9408 R_NDS32_HI20_RELA, laddr);
9409 lo_irelfn =
9410 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9411 R_NDS32_LO12S0_ORI_RELA, laddr + 4);
9412 if (hi_irelfn == irelend || lo_irelfn == irelend)
9413 {
9414 _bfd_error_handler
9415 ("%B: warning: R_NDS32_LONGJUMP1 points to unrecognized"
9416 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9417 return FALSE;
9418 }
9419
9420 /* Get the value of the symbol referred to by the reloc. */
9421 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9422 &pic_ext_target);
9423
9424 if (pic_ext_target || foff == 0 || foff >= CONSERVATIVE_24BIT_S1
9425 || foff < -CONSERVATIVE_24BIT_S1)
9426 return FALSE;
9427
9428 if (insn16_on && foff >= -ACCURATE_8BIT_S1
9429 && foff < ACCURATE_8BIT_S1 && (seq_len & 0x2))
9430 {
9431 /* j8 label */
9432 /* 16-bit on, but not optimized for speed. */
9433 reloc = R_NDS32_9_PCREL_RELA;
9434 insn16 = INSN_J8;
9435 bfd_putb16 (insn16, contents + irel->r_offset);
9436 *insn_len = 2;
9437 irel->r_info =
9438 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
9439 }
9440 else
9441 {
9442 /* j label */
9443 reloc = R_NDS32_25_PCREL_RELA;
9444 insn = INSN_J;
9445 bfd_putb32 (insn, contents + irel->r_offset);
9446 *insn_len = 4;
9447 irel->r_info =
9448 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_INSN16);
9449 irel->r_addend = 0;
9450 }
9451
9452 hi_irelfn->r_info =
9453 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
9454 lo_irelfn->r_info =
9455 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_NDS32_NONE);
9456
9457 if ((seq_len & 0x2) && ((*insn_len & 2) == 0))
9458 {
9459 insn16 = NDS32_NOP16;
9460 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9461 lo_irelfn->r_info =
9462 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9463 R_NDS32_INSN16);
9464 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9465 *insn_len += 2;
9466 }
9467 return TRUE;
9468 }
9469
9470 /* Revert condition branch. This function does not check if the input
9471 instruction is condition branch or not. */
9472
9473 static void
9474 nds32_elf_convert_branch (uint16_t insn16, uint32_t insn,
9475 uint16_t *re_insn16, uint32_t *re_insn)
9476 {
9477 uint32_t comp_insn = 0;
9478 uint16_t comp_insn16 = 0;
9479
9480 if (insn)
9481 {
9482 if (N32_OP6 (insn) == N32_OP6_BR1)
9483 {
9484 /* beqs label. */
9485 comp_insn = (insn ^ 0x4000) & 0xffffc000;
9486 if (N32_IS_RT3 (insn) && N32_RA5 (insn) == REG_R5)
9487 {
9488 /* Insn can be contracted to 16-bit implied r5. */
9489 comp_insn16 =
9490 (comp_insn & 0x4000) ? INSN_BNES38 : INSN_BEQS38;
9491 comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
9492 }
9493 }
9494 else if (N32_OP6 (insn) == N32_OP6_BR3)
9495 {
9496 /* bnec $ta, imm11, label. */
9497 comp_insn = (insn ^ 0x80000) & 0xffffff00;
9498 }
9499 else
9500 {
9501 comp_insn = (insn ^ 0x10000) & 0xffffc000;
9502 if (N32_BR2_SUB (insn) == N32_BR2_BEQZ
9503 || N32_BR2_SUB (insn) == N32_BR2_BNEZ)
9504 {
9505 if (N32_IS_RT3 (insn))
9506 {
9507 /* Insn can be contracted to 16-bit. */
9508 comp_insn16 =
9509 (comp_insn & 0x10000) ? INSN_BNEZ38 : INSN_BEQZ38;
9510 comp_insn16 |= (N32_RT5 (insn) & 0x7) << 8;
9511 }
9512 else if (N32_RT5 (insn) == REG_R15)
9513 {
9514 /* Insn can be contracted to 16-bit. */
9515 comp_insn16 =
9516 (comp_insn & 0x10000) ? INSN_BNES38 : INSN_BEQS38;
9517 }
9518 }
9519 }
9520 }
9521 else
9522 {
9523 switch ((insn16 & 0xf000) >> 12)
9524 {
9525 case 0xc:
9526 /* beqz38 or bnez38 */
9527 comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
9528 comp_insn = (comp_insn16 & 0x0800) ? INSN_BNEZ : INSN_BEQZ;
9529 comp_insn |= ((comp_insn16 & 0x0700) >> 8) << 20;
9530 break;
9531
9532 case 0xd:
9533 /* beqs38 or bnes38 */
9534 comp_insn16 = (insn16 ^ 0x0800) & 0xff00;
9535 comp_insn = (comp_insn16 & 0x0800) ? INSN_BNE : INSN_BEQ;
9536 comp_insn |= (((comp_insn16 & 0x0700) >> 8) << 20)
9537 | (REG_R5 << 15);
9538 break;
9539
9540 case 0xe:
9541 /* beqzS8 or bnezS8 */
9542 comp_insn16 = (insn16 ^ 0x0100) & 0xff00;
9543 comp_insn = (comp_insn16 & 0x0100) ? INSN_BNEZ : INSN_BEQZ;
9544 comp_insn |= REG_R15 << 20;
9545 break;
9546
9547 default:
9548 break;
9549 }
9550 }
9551 if (comp_insn && re_insn)
9552 *re_insn = comp_insn;
9553 if (comp_insn16 && re_insn16)
9554 *re_insn16 = comp_insn16;
9555 }
9556
9557 /* Relax LONGJUMP2 relocation for nds32_elf_relax_section. */
9558
9559 static bfd_boolean
9560 nds32_elf_relax_longjump2 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9561 Elf_Internal_Rela *internal_relocs, int *insn_len,
9562 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9563 Elf_Internal_Shdr *symtab_hdr)
9564 {
9565 /* There are 3 variations for LONGJUMP2
9566 case 2-4; 1st insn convertible, 16-bit on,
9567 optimize off or optimize for space
9568 bnes38 rt, ra, $1 ; LONGJUMP2
9569 j label ; 25_PCREL
9570 $1:
9571
9572 case 4-4; 1st insn not convertible
9573 bne rt, ra, $1 ; LONGJUMP2
9574 j label ; 25_PCREL
9575 $1:
9576
9577 case 4-4; 1st insn convertible, 16-bit on, optimize for speed
9578 bne rt, ra, $1 ; LONGJUMP2
9579 j label ; 25_PCREL
9580 $1: */
9581
9582 /* Get the reloc for the address from which the register is
9583 being loaded. This reloc will tell us which function is
9584 actually being called. */
9585
9586 bfd_vma laddr;
9587 int seq_len; /* Original length of instruction sequence. */
9588 Elf_Internal_Rela *i2_irelfn, *cond_irelfn, *irelend;
9589 int pic_ext_target = 0, first_size;
9590 unsigned int i;
9591 bfd_signed_vma foff;
9592 uint32_t insn, re_insn = 0;
9593 uint16_t insn16, re_insn16 = 0;
9594 unsigned long reloc, cond_reloc;
9595
9596 enum elf_nds32_reloc_type checked_types[] =
9597 { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
9598
9599 irelend = internal_relocs + sec->reloc_count;
9600 seq_len = GET_SEQ_LEN (irel->r_addend);
9601 laddr = irel->r_offset;
9602 *insn_len = seq_len;
9603 first_size = (seq_len == 6) ? 2 : 4;
9604
9605 i2_irelfn =
9606 find_relocs_at_address_addr (irel, internal_relocs,
9607 irelend, R_NDS32_25_PCREL_RELA,
9608 laddr + first_size);
9609
9610 for (i = 0; i < sizeof (checked_types) / sizeof(checked_types[0]); i++)
9611 {
9612 cond_irelfn =
9613 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9614 checked_types[i], laddr);
9615 if (cond_irelfn != irelend)
9616 break;
9617 }
9618
9619 if (i2_irelfn == irelend || cond_irelfn == irelend)
9620 {
9621 _bfd_error_handler
9622 ("%B: warning: R_NDS32_LONGJUMP2 points to unrecognized"
9623 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9624 return FALSE;
9625 }
9626
9627 /* Get the value of the symbol referred to by the reloc. */
9628 foff =
9629 calculate_offset (abfd, sec, i2_irelfn, isymbuf, symtab_hdr,
9630 &pic_ext_target);
9631 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_16BIT_S1
9632 || foff >= CONSERVATIVE_16BIT_S1)
9633 return FALSE;
9634
9635 /* Get the all corresponding instructions. */
9636 if (first_size == 4)
9637 {
9638 insn = bfd_getb32 (contents + laddr);
9639 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
9640 }
9641 else
9642 {
9643 insn16 = bfd_getb16 (contents + laddr);
9644 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
9645 }
9646
9647 if (re_insn16 && foff >= -(ACCURATE_8BIT_S1 - first_size)
9648 && foff < ACCURATE_8BIT_S1 - first_size)
9649 {
9650 if (first_size == 4)
9651 {
9652 /* Don't convert it to 16-bit now, keep this as relaxable for
9653 ``label reloc; INSN16''. */
9654
9655 /* Save comp_insn32 to buffer. */
9656 bfd_putb32 (re_insn, contents + irel->r_offset);
9657 *insn_len = 4;
9658 reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
9659 R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
9660 cond_reloc = R_NDS32_INSN16;
9661 }
9662 else
9663 {
9664 bfd_putb16 (re_insn16, contents + irel->r_offset);
9665 *insn_len = 2;
9666 reloc = R_NDS32_9_PCREL_RELA;
9667 cond_reloc = R_NDS32_NONE;
9668 }
9669 }
9670 else if (N32_OP6 (re_insn) == N32_OP6_BR1
9671 && (foff >= -(ACCURATE_14BIT_S1 - first_size)
9672 && foff < ACCURATE_14BIT_S1 - first_size))
9673 {
9674 /* beqs label ; 15_PCREL */
9675 bfd_putb32 (re_insn, contents + irel->r_offset);
9676 *insn_len = 4;
9677 reloc = R_NDS32_15_PCREL_RELA;
9678 cond_reloc = R_NDS32_NONE;
9679 }
9680 else if (N32_OP6 (re_insn) == N32_OP6_BR2
9681 && foff >= -CONSERVATIVE_16BIT_S1
9682 && foff < CONSERVATIVE_16BIT_S1)
9683 {
9684 /* beqz label ; 17_PCREL */
9685 bfd_putb32 (re_insn, contents + irel->r_offset);
9686 *insn_len = 4;
9687 reloc = R_NDS32_17_PCREL_RELA;
9688 cond_reloc = R_NDS32_NONE;
9689 }
9690 else
9691 return FALSE;
9692
9693 /* Set all relocations. */
9694 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info), reloc);
9695 irel->r_addend = i2_irelfn->r_addend;
9696
9697 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
9698 cond_reloc);
9699 cond_irelfn->r_addend = 0;
9700
9701 if ((seq_len ^ *insn_len ) & 0x2)
9702 {
9703 insn16 = NDS32_NOP16;
9704 bfd_putb16 (insn16, contents + irel->r_offset + 4);
9705 i2_irelfn->r_offset = 4;
9706 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
9707 R_NDS32_INSN16);
9708 i2_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9709 *insn_len += 2;
9710 }
9711 else
9712 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (i2_irelfn->r_info),
9713 R_NDS32_NONE);
9714 return TRUE;
9715 }
9716
9717 /* Relax LONGJUMP3 relocation for nds32_elf_relax_section. */
9718
9719 static bfd_boolean
9720 nds32_elf_relax_longjump3 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9721 Elf_Internal_Rela *internal_relocs, int *insn_len,
9722 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9723 Elf_Internal_Shdr *symtab_hdr)
9724 {
9725 /* There are 5 variations for LONGJUMP3
9726 case 1: 2-4-4-2; 1st insn convertible, 16-bit on,
9727 optimize off or optimize for space
9728 bnes38 rt, ra, $1 ; LONGJUMP3
9729 sethi ta, hi20(symbol) ; HI20
9730 ori ta, ta, lo12(symbol) ; LO12S0
9731 jr5 ta ;
9732 $1: ;
9733
9734 case 2: 2-4-4-2; 1st insn convertible, 16-bit on, optimize for speed
9735 bnes38 rt, ra, $1 ; LONGJUMP3
9736 sethi ta, hi20(symbol) ; HI20
9737 ori ta, ta, lo12(symbol) ; LO12S0
9738 jr5 ta ;
9739 $1: ; LABEL
9740
9741 case 3: 4-4-4-2; 1st insn not convertible, 16-bit on,
9742 optimize off or optimize for space
9743 bne rt, ra, $1 ; LONGJUMP3
9744 sethi ta, hi20(symbol) ; HI20
9745 ori ta, ta, lo12(symbol) ; LO12S0
9746 jr5 ta ;
9747 $1: ;
9748
9749 case 4: 4-4-4-4; 1st insn don't care, 16-bit off, optimize don't care
9750 16-bit off if no INSN16
9751 bne rt, ra, $1 ; LONGJUMP3
9752 sethi ta, hi20(symbol) ; HI20
9753 ori ta, ta, lo12(symbol) ; LO12S0
9754 jr ta ;
9755 $1: ;
9756
9757 case 5: 4-4-4-4; 1st insn not convertible, 16-bit on, optimize for speed
9758 16-bit off if no INSN16
9759 bne rt, ra, $1 ; LONGJUMP3
9760 sethi ta, hi20(symbol) ; HI20
9761 ori ta, ta, lo12(symbol) ; LO12S0
9762 jr ta ;
9763 $1: ; LABEL */
9764
9765 /* Get the reloc for the address from which the register is
9766 being loaded. This reloc will tell us which function is
9767 actually being called. */
9768 enum elf_nds32_reloc_type checked_types[] =
9769 { R_NDS32_15_PCREL_RELA, R_NDS32_9_PCREL_RELA };
9770
9771 int reloc_off = 0, cond_removed = 0, convertible;
9772 bfd_vma laddr;
9773 int seq_len; /* Original length of instruction sequence. */
9774 Elf_Internal_Rela *hi_irelfn, *lo_irelfn, *cond_irelfn, *irelend;
9775 int pic_ext_target = 0, first_size;
9776 unsigned int i;
9777 bfd_signed_vma foff;
9778 uint32_t insn, re_insn = 0;
9779 uint16_t insn16, re_insn16 = 0;
9780 unsigned long reloc, cond_reloc;
9781
9782 irelend = internal_relocs + sec->reloc_count;
9783 seq_len = GET_SEQ_LEN (irel->r_addend);
9784 laddr = irel->r_offset;
9785 *insn_len = seq_len;
9786
9787 convertible = IS_1ST_CONVERT (irel->r_addend);
9788
9789 if (convertible)
9790 first_size = 2;
9791 else
9792 first_size = 4;
9793
9794 /* Get all needed relocations. */
9795 hi_irelfn =
9796 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9797 R_NDS32_HI20_RELA, laddr + first_size);
9798 lo_irelfn =
9799 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9800 R_NDS32_LO12S0_ORI_RELA,
9801 laddr + first_size + 4);
9802
9803 for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
9804 {
9805 cond_irelfn =
9806 find_relocs_at_address_addr (irel, internal_relocs, irelend,
9807 checked_types[i], laddr);
9808 if (cond_irelfn != irelend)
9809 break;
9810 }
9811
9812 if (hi_irelfn == irelend || lo_irelfn == irelend || cond_irelfn == irelend)
9813 {
9814 _bfd_error_handler
9815 ("%B: warning: R_NDS32_LONGJUMP3 points to unrecognized"
9816 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9817 return FALSE;
9818 }
9819
9820 /* Get the value of the symbol referred to by the reloc. */
9821 foff = calculate_offset (abfd, sec, hi_irelfn, isymbuf, symtab_hdr,
9822 &pic_ext_target);
9823
9824 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
9825 || foff >= CONSERVATIVE_24BIT_S1)
9826 return FALSE;
9827
9828 /* Get the all corresponding instructions. */
9829 if (first_size == 4)
9830 {
9831 insn = bfd_getb32 (contents + laddr);
9832 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
9833 }
9834 else
9835 {
9836 insn16 = bfd_getb16 (contents + laddr);
9837 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
9838 }
9839
9840 /* For simplicity of coding, we are going to modify the section
9841 contents, the section relocs, and the BFD symbol table. We
9842 must tell the rest of the code not to free up this
9843 information. It would be possible to instead create a table
9844 of changes which have to be made, as is done in coff-mips.c;
9845 that would be more work, but would require less memory when
9846 the linker is run. */
9847
9848 if (re_insn16 && foff >= -ACCURATE_8BIT_S1 - first_size
9849 && foff < ACCURATE_8BIT_S1 - first_size)
9850 {
9851 if (!(seq_len & 0x2))
9852 {
9853 /* Don't convert it to 16-bit now, keep this as relaxable
9854 for ``label reloc; INSN1a''6. */
9855 /* Save comp_insn32 to buffer. */
9856 bfd_putb32 (re_insn, contents + irel->r_offset);
9857 *insn_len = 4;
9858 reloc = (N32_OP6 (re_insn) == N32_OP6_BR1) ?
9859 R_NDS32_15_PCREL_RELA : R_NDS32_17_PCREL_RELA;
9860 cond_reloc = R_NDS32_INSN16;
9861 }
9862 else
9863 {
9864 /* Not optimize for speed; convert sequence to 16-bit. */
9865 /* Save comp_insn16 to buffer. */
9866 bfd_putb16 (re_insn16, contents + irel->r_offset);
9867 *insn_len = 2;
9868 reloc = R_NDS32_9_PCREL_RELA;
9869 cond_reloc = R_NDS32_NONE;
9870 }
9871 cond_removed = 1;
9872 }
9873 else if (N32_OP6 (re_insn) == N32_OP6_BR1
9874 && (foff >= -(ACCURATE_14BIT_S1 - first_size)
9875 && foff < ACCURATE_14BIT_S1 - first_size))
9876 {
9877 /* beqs label ; 15_PCREL */
9878 bfd_putb32 (re_insn, contents + irel->r_offset);
9879 *insn_len = 4;
9880 reloc = R_NDS32_15_PCREL_RELA;
9881 cond_reloc = R_NDS32_NONE;
9882 cond_removed = 1;
9883 }
9884 else if (N32_OP6 (re_insn) == N32_OP6_BR2
9885 && foff >= -CONSERVATIVE_16BIT_S1
9886 && foff < CONSERVATIVE_16BIT_S1)
9887 {
9888 /* beqz label ; 17_PCREL */
9889 bfd_putb32 (re_insn, contents + irel->r_offset);
9890 *insn_len = 4;
9891 reloc = R_NDS32_17_PCREL_RELA;
9892 cond_reloc = R_NDS32_NONE;
9893 cond_removed = 1;
9894 }
9895 else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
9896 && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
9897 {
9898 /* Relax to one of the following 3 variations
9899
9900 case 2-4; 1st insn convertible, 16-bit on, optimize off or optimize
9901 for space
9902 bnes38 rt, $1 ; LONGJUMP2
9903 j label ; 25_PCREL
9904 $1
9905
9906 case 4-4; 1st insn not convertible, others don't care
9907 bne rt, ra, $1 ; LONGJUMP2
9908 j label ; 25_PCREL
9909 $1
9910
9911 case 4-4; 1st insn convertible, 16-bit on, optimize for speed
9912 bne rt, ra, $1 ; LONGJUMP2
9913 j label ; 25_PCREL
9914 $1 */
9915
9916 /* Offset for first instruction. */
9917
9918 /* Use j label as second instruction. */
9919 *insn_len = 4 + first_size;
9920 insn = INSN_J;
9921 bfd_putb32 (insn, contents + hi_irelfn->r_offset);
9922 reloc = R_NDS32_LONGJUMP2;
9923 cond_reloc = R_NDS32_25_PLTREL;
9924 }
9925 else
9926 return FALSE;
9927
9928 if (cond_removed == 1)
9929 {
9930 /* Set all relocations. */
9931 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), reloc);
9932 irel->r_addend = hi_irelfn->r_addend;
9933
9934 cond_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irelfn->r_info),
9935 cond_reloc);
9936 cond_irelfn->r_addend = 0;
9937 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9938 R_NDS32_NONE);
9939 }
9940 else
9941 {
9942 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
9943 irel->r_addend = irel->r_addend;
9944 hi_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info),
9945 cond_reloc);
9946 }
9947
9948 if ((seq_len ^ *insn_len ) & 0x2)
9949 {
9950 insn16 = NDS32_NOP16;
9951 bfd_putb16 (insn16, contents + irel->r_offset + *insn_len);
9952 lo_irelfn->r_offset = *insn_len;
9953 lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9954 R_NDS32_INSN16);
9955 lo_irelfn->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
9956 *insn_len += 2;
9957 }
9958 else
9959 lo_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info),
9960 R_NDS32_NONE);
9961 return TRUE;
9962 }
9963
9964 /* Relax LONGCALL4 relocation for nds32_elf_relax_section. */
9965
9966 static bfd_boolean
9967 nds32_elf_relax_longcall4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
9968 Elf_Internal_Rela *internal_relocs, int *insn_len,
9969 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
9970 Elf_Internal_Shdr *symtab_hdr)
9971 {
9972 /* The pattern for LONGCALL4. Support for function cse.
9973 sethi ta, hi20(symbol) ; LONGCALL4/HI20
9974 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
9975 jral ta ; PTR_RES/EMPTY/INSN16 */
9976
9977 bfd_vma laddr;
9978 uint32_t insn;
9979 Elf_Internal_Rela *hi_irel, *ptr_irel, *insn_irel, *em_irel, *call_irel;
9980 Elf_Internal_Rela *irelend;
9981 int pic_ext_target = 0;
9982 bfd_signed_vma foff;
9983
9984 irelend = internal_relocs + sec->reloc_count;
9985 laddr = irel->r_offset;
9986
9987 /* Get the reloc for the address from which the register is
9988 being loaded. This reloc will tell us which function is
9989 actually being called. */
9990 hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
9991 R_NDS32_HI20_RELA, laddr);
9992
9993 if (hi_irel == irelend)
9994 {
9995 _bfd_error_handler
9996 ("%B: warning: R_NDS32_LONGCALL4 points to unrecognized"
9997 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
9998 return FALSE;
9999 }
10000
10001 /* Get the value of the symbol referred to by the reloc. */
10002 foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr,
10003 &pic_ext_target);
10004
10005 /* This condition only happened when symbol is undefined. */
10006 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
10007 || foff >= CONSERVATIVE_24BIT_S1)
10008 return FALSE;
10009
10010 /* Relax to: jal symbol; 25_PCREL */
10011 /* For simplicity of coding, we are going to modify the section
10012 contents, the section relocs, and the BFD symbol table. We
10013 must tell the rest of the code not to free up this
10014 information. It would be possible to instead create a table
10015 of changes which have to be made, as is done in coff-mips.c;
10016 that would be more work, but would require less memory when
10017 the linker is run. */
10018
10019 ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10020 R_NDS32_PTR_RESOLVED, irel->r_addend);
10021 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10022 R_NDS32_EMPTY, irel->r_addend);
10023
10024 if (ptr_irel == irelend || em_irel == irelend)
10025 {
10026 _bfd_error_handler
10027 ("%B: warning: R_NDS32_LONGCALL4 points to unrecognized"
10028 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10029 return FALSE;
10030 }
10031 /* Check these is enough space to insert jal in R_NDS32_EMPTY. */
10032 insn = bfd_getb32 (contents + irel->r_addend);
10033 if (insn & 0x80000000)
10034 return FALSE;
10035
10036 /* Replace the long call with a jal. */
10037 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10038 R_NDS32_25_PCREL_RELA);
10039 ptr_irel->r_addend = 1;
10040
10041 /* We don't resolve this here but resolve it in relocate_section. */
10042 insn = INSN_JAL;
10043 bfd_putb32 (insn, contents + em_irel->r_offset);
10044
10045 irel->r_info =
10046 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10047
10048 /* If there is function cse, HI20 can not remove now. */
10049 call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10050 R_NDS32_LONGCALL4, laddr);
10051 if (call_irel == irelend)
10052 {
10053 *insn_len = 0;
10054 hi_irel->r_info =
10055 ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10056 }
10057
10058 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10059 R_NDS32_INSN16, irel->r_addend);
10060 if (insn_irel != irelend)
10061 insn_irel->r_info =
10062 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10063
10064 return TRUE;
10065 }
10066
10067 /* Relax LONGCALL5 relocation for nds32_elf_relax_section. */
10068
10069 static bfd_boolean
10070 nds32_elf_relax_longcall5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10071 Elf_Internal_Rela *internal_relocs, int *insn_len,
10072 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10073 Elf_Internal_Shdr *symtab_hdr)
10074 {
10075 /* The pattern for LONGCALL5.
10076 bltz rt, .L1 ; LONGCALL5/17_PCREL
10077 jal symbol ; 25_PCREL
10078 .L1: */
10079
10080 bfd_vma laddr;
10081 uint32_t insn;
10082 Elf_Internal_Rela *cond_irel, *irelend;
10083 int pic_ext_target = 0;
10084 bfd_signed_vma foff;
10085
10086 irelend = internal_relocs + sec->reloc_count;
10087 laddr = irel->r_offset;
10088 insn = bfd_getb32 (contents + laddr);
10089
10090 /* Get the reloc for the address from which the register is
10091 being loaded. This reloc will tell us which function is
10092 actually being called. */
10093 cond_irel =
10094 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10095 R_NDS32_25_PCREL_RELA, irel->r_addend);
10096 if (cond_irel == irelend)
10097 {
10098 _bfd_error_handler
10099 ("%B: warning: R_NDS32_LONGCALL5 points to unrecognized"
10100 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10101 return FALSE;
10102 }
10103
10104 /* Get the value of the symbol referred to by the reloc. */
10105 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10106 &pic_ext_target);
10107
10108 if (foff == 0 || foff < -CONSERVATIVE_16BIT_S1
10109 || foff >= CONSERVATIVE_16BIT_S1)
10110 return FALSE;
10111
10112 /* Relax to bgezal rt, label ; 17_PCREL
10113 or bltzal rt, label ; 17_PCREL */
10114
10115 /* Convert to complimentary conditional call. */
10116 insn = CONVERT_CONDITION_CALL (insn);
10117
10118 /* For simplicity of coding, we are going to modify the section
10119 contents, the section relocs, and the BFD symbol table. We
10120 must tell the rest of the code not to free up this
10121 information. It would be possible to instead create a table
10122 of changes which have to be made, as is done in coff-mips.c;
10123 that would be more work, but would require less memory when
10124 the linker is run. */
10125
10126 /* Modify relocation and contents. */
10127 cond_irel->r_info =
10128 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_17_PCREL_RELA);
10129
10130 /* Replace the long call with a bgezal. */
10131 bfd_putb32 (insn, contents + cond_irel->r_offset);
10132 *insn_len = 0;
10133
10134 /* Clean unnessary relocations. */
10135 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10136
10137 cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10138 R_NDS32_17_PCREL_RELA, laddr);
10139 cond_irel->r_info =
10140 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10141
10142 return TRUE;
10143 }
10144
10145 /* Relax LONGCALL6 relocation for nds32_elf_relax_section. */
10146
10147 static bfd_boolean
10148 nds32_elf_relax_longcall6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10149 Elf_Internal_Rela *internal_relocs, int *insn_len,
10150 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10151 Elf_Internal_Shdr *symtab_hdr)
10152 {
10153 /* The pattern for LONGCALL6.
10154 bltz rt, .L1 ; LONGCALL6/17_PCREL
10155 sethi ta, hi20(symbol) ; HI20/PTR
10156 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10157 jral ta ; PTR_RES/EMPTY/INSN16
10158 .L1 */
10159
10160 bfd_vma laddr;
10161 uint32_t insn;
10162 Elf_Internal_Rela *em_irel, *cond_irel, *irelend;
10163 int pic_ext_target = 0;
10164 bfd_signed_vma foff;
10165
10166 irelend = internal_relocs + sec->reloc_count;
10167 laddr = irel->r_offset;
10168
10169 /* Get the reloc for the address from which the register is
10170 being loaded. This reloc will tell us which function is
10171 actually being called. */
10172 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10173 R_NDS32_EMPTY, irel->r_addend);
10174
10175 if (em_irel == irelend)
10176 {
10177 _bfd_error_handler
10178 ("%B: warning: R_NDS32_LONGCALL6 points to unrecognized"
10179 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10180 return FALSE;
10181 }
10182
10183 /* Get the value of the symbol referred to by the reloc. */
10184 foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr,
10185 &pic_ext_target);
10186
10187 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
10188 || foff >= CONSERVATIVE_24BIT_S1)
10189 return FALSE;
10190
10191 /* Check these is enough space to insert jal in R_NDS32_EMPTY. */
10192 insn = bfd_getb32 (contents + irel->r_addend);
10193 if (insn & 0x80000000)
10194 return FALSE;
10195
10196 insn = bfd_getb32 (contents + laddr);
10197 if (foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10198 {
10199 /* Relax to bgezal rt, label ; 17_PCREL
10200 or bltzal rt, label ; 17_PCREL */
10201
10202 /* Convert to complimentary conditional call. */
10203 *insn_len = 0;
10204 insn = CONVERT_CONDITION_CALL (insn);
10205 bfd_putb32 (insn, contents + em_irel->r_offset);
10206
10207 em_irel->r_info =
10208 ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_17_PCREL_RELA);
10209
10210 /* Set resolved relocation. */
10211 cond_irel =
10212 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10213 R_NDS32_PTR_RESOLVED, irel->r_addend);
10214 if (cond_irel == irelend)
10215 {
10216 _bfd_error_handler
10217 ("%B: warning: R_NDS32_LONGCALL6 points to unrecognized"
10218 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10219 return FALSE;
10220 }
10221 cond_irel->r_addend = 1;
10222
10223 /* Clear relocations. */
10224
10225 irel->r_info =
10226 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10227
10228 cond_irel =
10229 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10230 R_NDS32_17_PCREL_RELA, laddr);
10231 if (cond_irel != irelend)
10232 cond_irel->r_info =
10233 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10234
10235 cond_irel =
10236 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10237 R_NDS32_INSN16, irel->r_addend);
10238 if (cond_irel != irelend)
10239 cond_irel->r_info =
10240 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10241
10242 }
10243 else if (foff >= -CONSERVATIVE_24BIT_S1 && foff < CONSERVATIVE_24BIT_S1)
10244 {
10245 /* Relax to the following instruction sequence
10246 bltz rt, .L1 ; LONGCALL2/17_PCREL
10247 jal symbol ; 25_PCREL/PTR_RES
10248 .L1 */
10249 *insn_len = 4;
10250 /* Convert instruction. */
10251 insn = INSN_JAL;
10252 bfd_putb32 (insn, contents + em_irel->r_offset);
10253
10254 /* Convert relocations. */
10255 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info),
10256 R_NDS32_25_PCREL_RELA);
10257 irel->r_info =
10258 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_LONGCALL5);
10259
10260 /* Set resolved relocation. */
10261 cond_irel =
10262 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10263 R_NDS32_PTR_RESOLVED, irel->r_addend);
10264 if (cond_irel == irelend)
10265 {
10266 _bfd_error_handler
10267 ("%B: warning: R_NDS32_LONGCALL6 points to unrecognized"
10268 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10269 return FALSE;
10270 }
10271 cond_irel->r_addend = 1;
10272
10273 cond_irel =
10274 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10275 R_NDS32_INSN16, irel->r_addend);
10276 if (cond_irel != irelend)
10277 cond_irel->r_info =
10278 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10279 }
10280 return TRUE;
10281 }
10282
10283 /* Relax LONGJUMP4 relocation for nds32_elf_relax_section. */
10284
10285 static bfd_boolean
10286 nds32_elf_relax_longjump4 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10287 Elf_Internal_Rela *internal_relocs, int *insn_len,
10288 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10289 Elf_Internal_Shdr *symtab_hdr)
10290 {
10291 /* The pattern for LONGJUMP4.
10292 sethi ta, hi20(symbol) ; LONGJUMP4/HI20
10293 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10294 jr ta ; PTR_RES/INSN16/EMPTY */
10295
10296 bfd_vma laddr;
10297 int seq_len; /* Original length of instruction sequence. */
10298 uint32_t insn;
10299 Elf_Internal_Rela *hi_irel, *ptr_irel, *em_irel, *call_irel, *irelend;
10300 int pic_ext_target = 0;
10301 bfd_signed_vma foff;
10302
10303 irelend = internal_relocs + sec->reloc_count;
10304 seq_len = GET_SEQ_LEN (irel->r_addend);
10305 laddr = irel->r_offset;
10306 *insn_len = seq_len;
10307
10308 /* Get the reloc for the address from which the register is
10309 being loaded. This reloc will tell us which function is
10310 actually being called. */
10311
10312 hi_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10313 R_NDS32_HI20_RELA, laddr);
10314
10315 if (hi_irel == irelend)
10316 {
10317 _bfd_error_handler
10318 ("%B: warning: R_NDS32_LONGJUMP4 points to unrecognized"
10319 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10320 return FALSE;
10321 }
10322
10323 /* Get the value of the symbol referred to by the reloc. */
10324 foff = calculate_offset (abfd, sec, hi_irel, isymbuf, symtab_hdr,
10325 &pic_ext_target);
10326
10327 if (pic_ext_target || foff == 0 || foff >= CONSERVATIVE_24BIT_S1
10328 || foff < -CONSERVATIVE_24BIT_S1)
10329 return FALSE;
10330
10331 /* Convert it to "j label", it may be converted to j8 in the final
10332 pass of relaxation. Therefore, we do not consider this currently. */
10333 ptr_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10334 R_NDS32_PTR_RESOLVED, irel->r_addend);
10335 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10336 R_NDS32_EMPTY, irel->r_addend);
10337
10338 if (ptr_irel == irelend || em_irel == irelend)
10339 {
10340 _bfd_error_handler
10341 ("%B: warning: R_NDS32_LONGJUMP4 points to unrecognized"
10342 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10343 return FALSE;
10344 }
10345
10346 em_irel->r_info =
10347 ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), R_NDS32_25_PCREL_RELA);
10348 ptr_irel->r_addend = 1;
10349
10350 /* Write instruction. */
10351 insn = INSN_J;
10352 bfd_putb32 (insn, contents + em_irel->r_offset);
10353
10354 /* Clear relocations. */
10355 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10356
10357 /* If there is function cse, HI20 can not remove now. */
10358 call_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10359 R_NDS32_LONGJUMP4, laddr);
10360 if (call_irel == irelend)
10361 {
10362 *insn_len = 0;
10363 hi_irel->r_info =
10364 ELF32_R_INFO (ELF32_R_SYM (hi_irel->r_info), R_NDS32_NONE);
10365 }
10366
10367 return TRUE;
10368 }
10369
10370 /* Relax LONGJUMP5 relocation for nds32_elf_relax_section. */
10371
10372 static bfd_boolean
10373 nds32_elf_relax_longjump5 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10374 Elf_Internal_Rela *internal_relocs, int *insn_len,
10375 int *seq_len, bfd_byte *contents,
10376 Elf_Internal_Sym *isymbuf,
10377 Elf_Internal_Shdr *symtab_hdr)
10378 {
10379 /* There are 2 variations for LONGJUMP5
10380 case 2-4; 1st insn convertible, 16-bit on.
10381 bnes38 rt, ra, .L1 ; LONGJUMP5/9_PCREL/INSN16
10382 j label ; 25_PCREL/INSN16
10383 $1:
10384
10385 case 4-4; 1st insn not convertible
10386 bne rt, ra, .L1 ; LONGJUMP5/15_PCREL/INSN16
10387 j label ; 25_PCREL/INSN16
10388 .L1: */
10389
10390 bfd_vma laddr;
10391 Elf_Internal_Rela *cond_irel, *irelend;
10392 int pic_ext_target = 0;
10393 unsigned int i;
10394 bfd_signed_vma foff;
10395 uint32_t insn, re_insn = 0;
10396 uint16_t insn16, re_insn16 = 0;
10397 unsigned long reloc;
10398
10399 enum elf_nds32_reloc_type checked_types[] =
10400 { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
10401 R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
10402
10403 irelend = internal_relocs + sec->reloc_count;
10404 laddr = irel->r_offset;
10405
10406 /* Get the reloc for the address from which the register is
10407 being loaded. This reloc will tell us which function is
10408 actually being called. */
10409
10410 cond_irel =
10411 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10412 R_NDS32_25_PCREL_RELA, irel->r_addend);
10413 if (cond_irel == irelend)
10414 {
10415 _bfd_error_handler
10416 ("%B: warning: R_NDS32_LONGJUMP5 points to unrecognized"
10417 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10418 return FALSE;
10419 }
10420
10421 /* Get the value of the symbol referred to by the reloc. */
10422 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10423 &pic_ext_target);
10424
10425 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_16BIT_S1
10426 || foff >= CONSERVATIVE_16BIT_S1)
10427 return FALSE;
10428
10429 /* Get the all corresponding instructions. */
10430 insn = bfd_getb32 (contents + laddr);
10431 /* Check instruction size. */
10432 if (insn & 0x80000000)
10433 {
10434 *seq_len = 0;
10435 insn16 = insn >> 16;
10436 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10437 }
10438 else
10439 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10440
10441 if (N32_OP6 (re_insn) == N32_OP6_BR1
10442 && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
10443 {
10444 /* beqs label ; 15_PCREL. */
10445 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10446 reloc = R_NDS32_15_PCREL_RELA;
10447 }
10448 else if (N32_OP6 (re_insn) == N32_OP6_BR2
10449 && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10450 {
10451 /* beqz label ; 17_PCREL. */
10452 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10453 reloc = R_NDS32_17_PCREL_RELA;
10454 }
10455 else if ( N32_OP6 (re_insn) == N32_OP6_BR3
10456 && foff >= -CONSERVATIVE_8BIT_S1 && foff < CONSERVATIVE_8BIT_S1)
10457 {
10458 /* beqc label ; 9_PCREL. */
10459 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10460 reloc = R_NDS32_WORD_9_PCREL_RELA;
10461 }
10462 else
10463 return FALSE;
10464
10465 /* Set all relocations. */
10466 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), reloc);
10467
10468 /* Clean relocations. */
10469 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10470 for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
10471 {
10472 cond_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10473 checked_types[i], laddr);
10474 if (cond_irel != irelend)
10475 {
10476 if (*seq_len == 0
10477 && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
10478 {
10479 /* If the branch instruction is 2 byte, it cannot remove
10480 directly. Only convert it to nop16 and remove it after
10481 checking alignment issue. */
10482 insn16 = NDS32_NOP16;
10483 bfd_putb16 (insn16, contents + laddr);
10484 cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10485 }
10486 else
10487 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10488 R_NDS32_NONE);
10489 }
10490 }
10491 *insn_len = 0;
10492
10493 return TRUE;
10494 }
10495
10496 /* Relax LONGJUMP6 relocation for nds32_elf_relax_section. */
10497
10498 static bfd_boolean
10499 nds32_elf_relax_longjump6 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10500 Elf_Internal_Rela *internal_relocs, int *insn_len,
10501 int *seq_len, bfd_byte *contents,
10502 Elf_Internal_Sym *isymbuf,
10503 Elf_Internal_Shdr *symtab_hdr)
10504 {
10505 /* There are 5 variations for LONGJUMP6
10506 case : 2-4-4-4; 1st insn convertible, 16-bit on.
10507 bnes38 rt, ra, .L1 ; LONGJUMP6/15_PCREL/INSN16
10508 sethi ta, hi20(symbol) ; HI20/PTR
10509 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10510 jr ta ; PTR_RES/INSN16/EMPTY
10511 .L1:
10512
10513 case : 4-4-4-4; 1st insn not convertible, 16-bit on.
10514 bne rt, ra, .L1 ; LONGJUMP6/15_PCREL/INSN16
10515 sethi ta, hi20(symbol) ; HI20/PTR
10516 ori ta, ta, lo12(symbol) ; LO12S0_ORI/PTR
10517 jr ta ; PTR_RES/INSN16/EMPTY
10518 .L1: */
10519
10520 enum elf_nds32_reloc_type checked_types[] =
10521 { R_NDS32_17_PCREL_RELA, R_NDS32_15_PCREL_RELA,
10522 R_NDS32_9_PCREL_RELA, R_NDS32_INSN16 };
10523
10524 int reloc_off = 0, cond_removed = 0;
10525 bfd_vma laddr;
10526 Elf_Internal_Rela *cond_irel, *em_irel, *irelend, *insn_irel;
10527 int pic_ext_target = 0;
10528 unsigned int i;
10529 bfd_signed_vma foff;
10530 uint32_t insn, re_insn = 0;
10531 uint16_t insn16, re_insn16 = 0;
10532 unsigned long reloc;
10533
10534 irelend = internal_relocs + sec->reloc_count;
10535 laddr = irel->r_offset;
10536
10537 /* Get the reloc for the address from which the register is
10538 being loaded. This reloc will tell us which function is
10539 actually being called. */
10540 em_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10541 R_NDS32_EMPTY, irel->r_addend);
10542
10543 if (em_irel == irelend)
10544 {
10545 _bfd_error_handler
10546 ("%B: warning: R_NDS32_LONGJUMP6 points to unrecognized"
10547 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10548 return FALSE;
10549 }
10550
10551 /* Get the value of the symbol referred to by the reloc. */
10552 foff = calculate_offset (abfd, sec, em_irel, isymbuf, symtab_hdr,
10553 &pic_ext_target);
10554
10555 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_24BIT_S1
10556 || foff >= CONSERVATIVE_24BIT_S1)
10557 return FALSE;
10558
10559 insn = bfd_getb32 (contents + laddr);
10560 /* Check instruction size. */
10561 if (insn & 0x80000000)
10562 {
10563 *seq_len = 0;
10564 insn16 = insn >> 16;
10565 nds32_elf_convert_branch (insn16, 0, &re_insn16, &re_insn);
10566 }
10567 else
10568 nds32_elf_convert_branch (0, insn, &re_insn16, &re_insn);
10569
10570 /* For simplicity of coding, we are going to modify the section
10571 contents, the section relocs, and the BFD symbol table. We
10572 must tell the rest of the code not to free up this
10573 information. It would be possible to instead create a table
10574 of changes which have to be made, as is done in coff-mips.c;
10575 that would be more work, but would require less memory when
10576 the linker is run. */
10577
10578 if (N32_OP6 (re_insn) == N32_OP6_BR1
10579 && (foff >= -CONSERVATIVE_14BIT_S1 && foff < CONSERVATIVE_14BIT_S1))
10580 {
10581 /* beqs label ; 15_PCREL */
10582 bfd_putb32 (re_insn, contents + em_irel->r_offset);
10583 reloc = R_NDS32_15_PCREL_RELA;
10584 cond_removed = 1;
10585 }
10586 else if (N32_OP6 (re_insn) == N32_OP6_BR2
10587 && foff >= -CONSERVATIVE_16BIT_S1 && foff < CONSERVATIVE_16BIT_S1)
10588 {
10589 /* beqz label ; 17_PCREL */
10590 bfd_putb32 (re_insn, contents + em_irel->r_offset);
10591 reloc = R_NDS32_17_PCREL_RELA;
10592 cond_removed = 1;
10593 }
10594 else if (foff >= -CONSERVATIVE_24BIT_S1 - reloc_off
10595 && foff < CONSERVATIVE_24BIT_S1 - reloc_off)
10596 {
10597 /* Relax to one of the following 2 variations
10598
10599 case 2-4; 1st insn convertible, 16-bit on.
10600 bnes38 rt, ra, .L1 ; LONGJUMP5/9_PCREL/INSN16
10601 j label ; 25_PCREL/INSN16
10602 $1:
10603
10604 case 4-4; 1st insn not convertible
10605 bne rt, ra, .L1 ; LONGJUMP5/15_PCREL/INSN16
10606 j label ; 25_PCREL/INSN16
10607 .L1: */
10608
10609 /* Use j label as second instruction. */
10610 insn = INSN_J;
10611 reloc = R_NDS32_25_PCREL_RELA;
10612 bfd_putb32 (insn, contents + em_irel->r_offset);
10613 }
10614 else
10615 return FALSE;
10616
10617 /* Set all relocations. */
10618 em_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (em_irel->r_info), reloc);
10619
10620 cond_irel =
10621 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10622 R_NDS32_PTR_RESOLVED, em_irel->r_offset);
10623 cond_irel->r_addend = 1;
10624
10625 /* Use INSN16 of first branch instruction to distinguish if keeping
10626 INSN16 of final instruction or not. */
10627 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10628 R_NDS32_INSN16, irel->r_offset);
10629 if (insn_irel == irelend)
10630 {
10631 /* Clean the final INSN16. */
10632 insn_irel =
10633 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10634 R_NDS32_INSN16, em_irel->r_offset);
10635 insn_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10636 R_NDS32_NONE);
10637 }
10638
10639 if (cond_removed == 1)
10640 {
10641 *insn_len = 0;
10642
10643 /* Clear relocations. */
10644 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10645
10646 for (i = 0; i < sizeof (checked_types) / sizeof (checked_types[0]); i++)
10647 {
10648 cond_irel =
10649 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10650 checked_types[i], laddr);
10651 if (cond_irel != irelend)
10652 {
10653 if (*seq_len == 0
10654 && (ELF32_R_TYPE (cond_irel->r_info) == R_NDS32_INSN16))
10655 {
10656 /* If the branch instruction is 2 byte, it cannot remove
10657 directly. Only convert it to nop16 and remove it after
10658 checking alignment issue. */
10659 insn16 = NDS32_NOP16;
10660 bfd_putb16 (insn16, contents + laddr);
10661 cond_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10662 }
10663 else
10664 cond_irel->r_info =
10665 ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info), R_NDS32_NONE);
10666 }
10667 }
10668 }
10669 else
10670 {
10671 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
10672 R_NDS32_LONGJUMP5);
10673 }
10674
10675 return TRUE;
10676 }
10677
10678 /* Relax LONGJUMP7 relocation for nds32_elf_relax_section. */
10679
10680 static bfd_boolean
10681 nds32_elf_relax_longjump7 (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
10682 Elf_Internal_Rela *internal_relocs, int *insn_len,
10683 int *seq_len, bfd_byte *contents,
10684 Elf_Internal_Sym *isymbuf,
10685 Elf_Internal_Shdr *symtab_hdr)
10686 {
10687 /* There are 2 variations for LONGJUMP5
10688 case 2-4; 1st insn convertible, 16-bit on.
10689 movi55 ta, imm11 ; LONGJUMP7/INSN16
10690 beq rt, ta, label ; 15_PCREL
10691
10692 case 4-4; 1st insn not convertible
10693 movi55 ta, imm11 ; LONGJUMP7/INSN16
10694 beq rt, ta, label ; 15_PCREL */
10695
10696 bfd_vma laddr;
10697 Elf_Internal_Rela *cond_irel, *irelend, *insn_irel;
10698 int pic_ext_target = 0;
10699 bfd_signed_vma foff;
10700 uint32_t insn, re_insn = 0;
10701 uint16_t insn16;
10702 uint32_t imm11;
10703
10704 irelend = internal_relocs + sec->reloc_count;
10705 laddr = irel->r_offset;
10706
10707 /* Get the reloc for the address from which the register is
10708 being loaded. This reloc will tell us which function is
10709 actually being called. */
10710
10711 cond_irel =
10712 find_relocs_at_address_addr (irel, internal_relocs, irelend,
10713 R_NDS32_15_PCREL_RELA, irel->r_addend);
10714 if (cond_irel == irelend)
10715 {
10716 _bfd_error_handler
10717 ("%B: warning: R_NDS32_LONGJUMP7 points to unrecognized"
10718 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10719 return FALSE;
10720 }
10721
10722 /* Get the value of the symbol referred to by the reloc. */
10723 foff = calculate_offset (abfd, sec, cond_irel, isymbuf, symtab_hdr,
10724 &pic_ext_target);
10725
10726 if (pic_ext_target || foff == 0 || foff < -CONSERVATIVE_8BIT_S1
10727 || foff >= CONSERVATIVE_8BIT_S1)
10728 return FALSE;
10729
10730 /* Get the first instruction for its size. */
10731 insn = bfd_getb32 (contents + laddr);
10732 if (insn & 0x80000000)
10733 {
10734 *seq_len = 0;
10735 /* Get the immediate from movi55. */
10736 imm11 = N16_IMM5S (insn >> 16);
10737 }
10738 else
10739 {
10740 /* Get the immediate from movi. */
10741 imm11 = N32_IMM20S (insn);
10742 }
10743
10744 /* Get the branch instruction. */
10745 insn = bfd_getb32 (contents + irel->r_addend);
10746 /* Convert instruction to BR3. */
10747 if ((insn >> 14) & 0x1)
10748 re_insn = N32_BR3 (BNEC, N32_RT5 (insn), imm11, 0);
10749 else
10750 re_insn = N32_BR3 (BEQC, N32_RT5 (insn), imm11, 0);
10751
10752 bfd_putb32 (re_insn, contents + cond_irel->r_offset);
10753
10754 /* Set all relocations. */
10755 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10756 R_NDS32_WORD_9_PCREL_RELA);
10757
10758 /* Clean relocations. */
10759 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10760 insn_irel = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10761 R_NDS32_INSN16, irel->r_offset);
10762 if (insn_irel != irelend)
10763 {
10764 if (*seq_len == 0)
10765 {
10766 /* If the first insntruction is 16bit, convert it to nop16. */
10767 insn16 = NDS32_NOP16;
10768 bfd_putb16 (insn16, contents + laddr);
10769 insn_irel->r_addend = R_NDS32_INSN16_CONVERT_FLAG;
10770 }
10771 else
10772 cond_irel->r_info = ELF32_R_INFO (ELF32_R_SYM (cond_irel->r_info),
10773 R_NDS32_NONE);
10774 }
10775 *insn_len = 0;
10776
10777 return TRUE;
10778 }
10779
10780 #define GET_LOADSTORE_RANGE(addend) (((addend) >> 8) & 0x3f)
10781
10782 /* Relax LOADSTORE relocation for nds32_elf_relax_section. */
10783
10784 static bfd_boolean
10785 nds32_elf_relax_loadstore (struct bfd_link_info *link_info, bfd *abfd,
10786 asection *sec, Elf_Internal_Rela *irel,
10787 Elf_Internal_Rela *internal_relocs, int *insn_len,
10788 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
10789 Elf_Internal_Shdr *symtab_hdr, int load_store_relax)
10790 {
10791 int eliminate_sethi = 0, range_type;
10792 unsigned int i;
10793 bfd_vma local_sda, laddr;
10794 int seq_len; /* Original length of instruction sequence. */
10795 uint32_t insn;
10796 Elf_Internal_Rela *hi_irelfn = NULL, *irelend;
10797 bfd_vma access_addr = 0;
10798 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
10799 enum elf_nds32_reloc_type checked_types[] =
10800 { R_NDS32_HI20_RELA, R_NDS32_GOT_HI20,
10801 R_NDS32_GOTPC_HI20, R_NDS32_GOTOFF_HI20,
10802 R_NDS32_PLTREL_HI20, R_NDS32_PLT_GOTREL_HI20,
10803 R_NDS32_TLS_LE_HI20
10804 };
10805
10806 irelend = internal_relocs + sec->reloc_count;
10807 seq_len = GET_SEQ_LEN (irel->r_addend);
10808 laddr = irel->r_offset;
10809 *insn_len = seq_len;
10810
10811 /* Get the high part relocation. */
10812 for (i = 0; i < ARRAY_SIZE (checked_types); i++)
10813 {
10814 hi_irelfn = find_relocs_at_address_addr (irel, internal_relocs, irelend,
10815 checked_types[i], laddr);
10816 if (hi_irelfn != irelend)
10817 break;
10818 }
10819
10820 if (hi_irelfn == irelend)
10821 {
10822 _bfd_error_handler
10823 ("%B: warning: R_NDS32_LOADSTORE points to unrecognized"
10824 "reloc at 0x%lx.", abfd, (long) irel->r_offset);
10825 return FALSE;
10826 }
10827
10828 range_type = GET_LOADSTORE_RANGE (irel->r_addend);
10829 nds32_elf_final_sda_base (sec->output_section->owner,
10830 link_info, &local_sda, FALSE);
10831
10832 switch (ELF32_R_TYPE (hi_irelfn->r_info))
10833 {
10834 case R_NDS32_HI20_RELA:
10835 insn = bfd_getb32 (contents + laddr);
10836 access_addr =
10837 calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10838
10839 if (range_type == NDS32_LOADSTORE_IMM)
10840 {
10841 struct elf_link_hash_entry *h = NULL;
10842 int indx;
10843
10844 if (ELF32_R_SYM (hi_irelfn->r_info) >= symtab_hdr->sh_info)
10845 {
10846 indx = ELF32_R_SYM (hi_irelfn->r_info) - symtab_hdr->sh_info;
10847 h = elf_sym_hashes (abfd)[indx];
10848 }
10849
10850 if ((access_addr < CONSERVATIVE_20BIT)
10851 && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
10852 {
10853 eliminate_sethi = 1;
10854 break;
10855 }
10856
10857 /* This is avoid to relax symbol address which is fixed
10858 relocations. Ex: _stack. */
10859 if (h && bfd_is_abs_section (h->root.u.def.section))
10860 return FALSE;
10861 }
10862
10863 if (!load_store_relax)
10864 return FALSE;
10865
10866 /* Case for set gp register. */
10867 if (N32_RT5 (insn) == REG_GP)
10868 break;
10869
10870 if (range_type == NDS32_LOADSTORE_FLOAT_S
10871 || range_type == NDS32_LOADSTORE_FLOAT_S)
10872 {
10873 range_l = sdata_range[0][0];
10874 range_h = sdata_range[0][1];
10875 }
10876 else
10877 {
10878 range_l = sdata_range[1][0];
10879 range_h = sdata_range[1][1];
10880 }
10881 break;
10882
10883 case R_NDS32_GOT_HI20:
10884 access_addr =
10885 calculate_got_memory_address (abfd, link_info, hi_irelfn, symtab_hdr);
10886
10887 /* If this symbol is not in .got, the return value will be -1.
10888 Since the gp value is set to SDA_BASE but not GLOBAL_OFFSET_TABLE,
10889 a negative offset is allowed. */
10890 if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10891 && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10892 eliminate_sethi = 1;
10893 break;
10894
10895 case R_NDS32_PLT_GOTREL_HI20:
10896 access_addr = calculate_plt_memory_address (abfd, link_info, isymbuf,
10897 hi_irelfn, symtab_hdr);
10898
10899 if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10900 && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10901 eliminate_sethi = 1;
10902 break;
10903
10904 case R_NDS32_GOTOFF_HI20:
10905 access_addr =
10906 calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10907
10908 if ((bfd_signed_vma) (access_addr - local_sda) < CONSERVATIVE_20BIT
10909 && (bfd_signed_vma) (access_addr - local_sda) >= -CONSERVATIVE_20BIT)
10910 eliminate_sethi = 1;
10911 break;
10912
10913 case R_NDS32_GOTPC_HI20:
10914 /* The access_addr must consider r_addend of hi_irel. */
10915 access_addr = sec->output_section->vma + sec->output_offset
10916 + irel->r_offset + hi_irelfn->r_addend;
10917
10918 if ((bfd_signed_vma) (local_sda - access_addr) < CONSERVATIVE_20BIT
10919 && (bfd_signed_vma) (local_sda - access_addr) >= -CONSERVATIVE_20BIT)
10920 eliminate_sethi = 1;
10921 break;
10922
10923 case R_NDS32_TLS_LE_HI20:
10924 access_addr =
10925 calculate_memory_address (abfd, hi_irelfn, isymbuf, symtab_hdr);
10926 BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
10927 access_addr -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
10928 if ((range_type == NDS32_LOADSTORE_IMM)
10929 && (bfd_signed_vma) (access_addr) < CONSERVATIVE_20BIT
10930 && (bfd_signed_vma) (access_addr) >= -CONSERVATIVE_20BIT)
10931 eliminate_sethi = 1;
10932 break;
10933
10934 default:
10935 return FALSE;
10936 }
10937
10938 /* Delete sethi instruction. */
10939 if (eliminate_sethi == 1
10940 || (local_sda <= access_addr && (access_addr - local_sda) < range_h)
10941 || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
10942 {
10943 hi_irelfn->r_info =
10944 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_NDS32_NONE);
10945 irel->r_info =
10946 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
10947 *insn_len = 0;
10948 }
10949 return TRUE;
10950 }
10951
10952 /* Relax LO12 relocation for nds32_elf_relax_section. */
10953
10954 static void
10955 nds32_elf_relax_lo12 (struct bfd_link_info *link_info, bfd *abfd,
10956 asection *sec, Elf_Internal_Rela *irel,
10957 Elf_Internal_Rela *internal_relocs, bfd_byte *contents,
10958 Elf_Internal_Sym *isymbuf, Elf_Internal_Shdr *symtab_hdr)
10959 {
10960 uint32_t insn;
10961 bfd_vma local_sda, laddr;
10962 unsigned long reloc;
10963 bfd_vma access_addr;
10964 bfd_vma range_l = 0, range_h = 0; /* Upper/lower bound. */
10965 Elf_Internal_Rela *irelfn = NULL, *irelend;
10966 struct elf_link_hash_entry *h = NULL;
10967 int indx;
10968
10969 /* For SDA base relative relaxation. */
10970 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
10971 &local_sda, FALSE);
10972
10973 irelend = internal_relocs + sec->reloc_count;
10974 laddr = irel->r_offset;
10975 insn = bfd_getb32 (contents + laddr);
10976
10977 if (!is_sda_access_insn (insn) && N32_OP6 (insn) != N32_OP6_ORI)
10978 return;
10979
10980 access_addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
10981
10982 if (ELF32_R_SYM (irel->r_info) >= symtab_hdr->sh_info)
10983 {
10984 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
10985 h = elf_sym_hashes (abfd)[indx];
10986 }
10987
10988 if (N32_OP6 (insn) == N32_OP6_ORI && access_addr < CONSERVATIVE_20BIT
10989 && (!h || (h && strcmp (h->root.root.string, FP_BASE_NAME) != 0)))
10990 {
10991 reloc = R_NDS32_20_RELA;
10992 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
10993 insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
10994 bfd_putb32 (insn, contents + laddr);
10995 }
10996 /* This is avoid to relax symbol address which is fixed
10997 relocations. Ex: _stack. */
10998 else if (N32_OP6 (insn) == N32_OP6_ORI
10999 && h && bfd_is_abs_section (h->root.u.def.section))
11000 return;
11001 else
11002 {
11003 range_l = sdata_range[1][0];
11004 range_h = sdata_range[1][1];
11005 switch (ELF32_R_TYPE (irel->r_info))
11006 {
11007 case R_NDS32_LO12S0_RELA:
11008 reloc = R_NDS32_SDA19S0_RELA;
11009 break;
11010 case R_NDS32_LO12S1_RELA:
11011 reloc = R_NDS32_SDA18S1_RELA;
11012 break;
11013 case R_NDS32_LO12S2_RELA:
11014 reloc = R_NDS32_SDA17S2_RELA;
11015 break;
11016 case R_NDS32_LO12S2_DP_RELA:
11017 range_l = sdata_range[0][0];
11018 range_h = sdata_range[0][1];
11019 reloc = R_NDS32_SDA12S2_DP_RELA;
11020 break;
11021 case R_NDS32_LO12S2_SP_RELA:
11022 range_l = sdata_range[0][0];
11023 range_h = sdata_range[0][1];
11024 reloc = R_NDS32_SDA12S2_SP_RELA;
11025 break;
11026 default:
11027 return;
11028 }
11029
11030 /* There are range_h and range_l because linker has to promise
11031 all sections move cross one page together. */
11032 if ((local_sda <= access_addr && (access_addr - local_sda) < range_h)
11033 || (local_sda > access_addr && (local_sda - access_addr) <= range_l))
11034 {
11035 if (N32_OP6 (insn) == N32_OP6_ORI && N32_RT5 (insn) == REG_GP)
11036 {
11037 /* Maybe we should add R_NDS32_INSN16 reloc type here
11038 or manually do some optimization. sethi can't be
11039 eliminated when updating $gp so the relative ori
11040 needs to be preserved. */
11041 return;
11042 }
11043 if (!turn_insn_to_sda_access (insn, ELF32_R_TYPE (irel->r_info),
11044 &insn))
11045 return;
11046 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11047 bfd_putb32 (insn, contents + laddr);
11048
11049 irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11050 R_NDS32_INSN16);
11051 /* SDA17 must keep INSN16 for converting fp_as_gp. */
11052 if (irelfn != irelend && reloc != R_NDS32_SDA17S2_RELA)
11053 irelfn->r_info =
11054 ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_NDS32_NONE);
11055
11056 }
11057 }
11058 return;
11059 }
11060
11061 /* Relax low part of PIC instruction pattern. */
11062
11063 static void
11064 nds32_elf_relax_piclo12 (struct bfd_link_info *link_info, bfd *abfd,
11065 asection *sec, Elf_Internal_Rela *irel,
11066 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11067 Elf_Internal_Shdr *symtab_hdr)
11068 {
11069 uint32_t insn;
11070 bfd_vma local_sda, laddr;
11071 bfd_signed_vma foff;
11072 unsigned long reloc;
11073
11074 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11075 &local_sda, FALSE);
11076 laddr = irel->r_offset;
11077 insn = bfd_getb32 (contents + laddr);
11078
11079 if (N32_OP6 (insn) != N32_OP6_ORI)
11080 return;
11081
11082 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12)
11083 {
11084 foff = calculate_got_memory_address (abfd, link_info, irel,
11085 symtab_hdr) - local_sda;
11086 reloc = R_NDS32_GOT20;
11087 }
11088 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12)
11089 {
11090 foff = calculate_plt_memory_address (abfd, link_info, isymbuf, irel,
11091 symtab_hdr) - local_sda;
11092 reloc = R_NDS32_PLT_GOTREL_LO20;
11093 }
11094 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12)
11095 {
11096 foff = calculate_memory_address (abfd, irel, isymbuf,
11097 symtab_hdr) - local_sda;
11098 reloc = R_NDS32_GOTOFF;
11099 }
11100 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12)
11101 {
11102 foff = local_sda - sec->output_section->vma + sec->output_offset
11103 + irel->r_offset + irel->r_addend;
11104 reloc = R_NDS32_GOTPC20;
11105 }
11106 else
11107 return;
11108
11109 if ((foff < CONSERVATIVE_20BIT) && (foff >= -CONSERVATIVE_20BIT))
11110 {
11111 /* Turn into MOVI. */
11112 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11113 insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
11114 bfd_putb32 (insn, contents + laddr);
11115 }
11116 }
11117
11118 /* Relax low part of LE TLS instruction pattern. */
11119
11120 static void
11121 nds32_elf_relax_letlslo12 (struct bfd_link_info *link_info, bfd *abfd,
11122 Elf_Internal_Rela *irel,
11123 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11124 Elf_Internal_Shdr *symtab_hdr)
11125 {
11126 uint32_t insn;
11127 bfd_vma laddr;
11128 bfd_signed_vma foff;
11129 unsigned long reloc;
11130
11131 laddr = irel->r_offset;
11132 foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11133 BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
11134 foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
11135 insn = bfd_getb32 (contents + laddr);
11136
11137 if ( (bfd_signed_vma) (foff) < CONSERVATIVE_20BIT
11138 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_20BIT)
11139 {
11140 /* Pattern sethi-ori transform to movi. */
11141 reloc = R_NDS32_TLS_LE_20;
11142 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), reloc);
11143 insn = N32_TYPE1 (MOVI, N32_RT5 (insn), 0);
11144 bfd_putb32 (insn, contents + laddr);
11145 }
11146 }
11147
11148 /* Relax LE TLS calculate address instruction pattern. */
11149
11150 static void
11151 nds32_elf_relax_letlsadd (struct bfd_link_info *link_info, bfd *abfd,
11152 asection *sec, Elf_Internal_Rela *irel,
11153 Elf_Internal_Rela *internal_relocs,
11154 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11155 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11156 {
11157 /* Local TLS non-pic
11158 sethi ta, hi20(symbol@tpoff) ; TLS_LE_HI20
11159 ori ta, ta, lo12(symbol@tpoff) ; TLS_LE_LO12
11160 add ra, ta, tp ; TLS_LE_ADD */
11161
11162 uint32_t insn;
11163 bfd_vma laddr;
11164 bfd_signed_vma foff;
11165 Elf_Internal_Rela *i1_irelfn, *irelend;
11166
11167 irelend = internal_relocs + sec->reloc_count;
11168 laddr = irel->r_offset;
11169 insn = bfd_getb32 (contents + laddr);
11170 i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11171 R_NDS32_PTR_RESOLVED);
11172 foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11173 BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
11174 foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
11175
11176 /* The range is +/-16k. */
11177 if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT
11178 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT)
11179 {
11180 /* Transform add to addi. */
11181 insn = N32_TYPE2 (ADDI, N32_RT5 (insn), N32_RB5 (insn), 0);
11182 irel->r_info =
11183 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S0);
11184
11185 bfd_putb32 (insn, contents + laddr);
11186 if (i1_irelfn != irelend)
11187 {
11188 i1_irelfn->r_addend |= 1;
11189 *again = TRUE;
11190 }
11191 }
11192 }
11193
11194 /* Relax LE TLS load store instruction pattern. */
11195
11196 static void
11197 nds32_elf_relax_letlsls (struct bfd_link_info *link_info, bfd *abfd,
11198 asection *sec, Elf_Internal_Rela *irel,
11199 Elf_Internal_Rela *internal_relocs,
11200 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11201 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11202 {
11203
11204 uint32_t insn;
11205 bfd_vma laddr;
11206 bfd_signed_vma foff;
11207 Elf_Internal_Rela *i1_irelfn, *irelend;
11208 int success = 0;
11209
11210 irelend = internal_relocs + sec->reloc_count;
11211 laddr = irel->r_offset;
11212 insn = bfd_getb32 (contents + laddr);
11213 i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11214 R_NDS32_PTR_RESOLVED);
11215 foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11216 BFD_ASSERT (elf_hash_table (link_info)->tls_sec != NULL);
11217 foff -= (elf_hash_table (link_info)->tls_sec->vma + TP_OFFSET);
11218
11219 switch ((N32_OP6 (insn) << 8) | (insn & 0xff))
11220 {
11221 case (N32_OP6_MEM << 8) | N32_MEM_LB:
11222 case (N32_OP6_MEM << 8) | N32_MEM_SB:
11223 case (N32_OP6_MEM << 8) | N32_MEM_LBS:
11224 /* The range is +/-16k. */
11225 if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT
11226 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT)
11227 {
11228 insn =
11229 ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
11230 irel->r_info =
11231 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S0);
11232 success = 1;
11233 break;
11234 }
11235 /* Fall through. */
11236 case (N32_OP6_MEM << 8) | N32_MEM_LH:
11237 case (N32_OP6_MEM << 8) | N32_MEM_SH:
11238 case (N32_OP6_MEM << 8) | N32_MEM_LHS:
11239 /* The range is +/-32k. */
11240 if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT_S1
11241 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT_S1)
11242 {
11243 insn =
11244 ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
11245 irel->r_info =
11246 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S1);
11247 success = 1;
11248 break;
11249 }
11250 /* Fall through. */
11251 case (N32_OP6_MEM << 8) | N32_MEM_LW:
11252 case (N32_OP6_MEM << 8) | N32_MEM_SW:
11253 /* The range is +/-64k. */
11254 if ((bfd_signed_vma) (foff) < CONSERVATIVE_15BIT_S2
11255 && (bfd_signed_vma) (foff) >= -CONSERVATIVE_15BIT_S2)
11256 {
11257 insn =
11258 ((insn & 0xff) << 25) | (insn & 0x1f00000) | ((insn & 0x7c00) << 5);
11259 irel->r_info =
11260 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_TLS_LE_15S2);
11261 success = 1;
11262 break;
11263 }
11264 /* Fall through. */
11265 default:
11266 break;
11267 }
11268
11269 if (success)
11270 {
11271 bfd_putb32 (insn, contents + laddr);
11272 if (i1_irelfn != irelend)
11273 {
11274 i1_irelfn->r_addend |= 1;
11275 *again = TRUE;
11276 }
11277 }
11278 }
11279
11280 /* Relax PTR relocation for nds32_elf_relax_section. */
11281
11282 static bfd_boolean
11283 nds32_elf_relax_ptr (bfd *abfd, asection *sec, Elf_Internal_Rela *irel,
11284 Elf_Internal_Rela *internal_relocs, int *insn_len,
11285 int *seq_len, bfd_byte *contents)
11286 {
11287 Elf_Internal_Rela *ptr_irel, *irelend, *count_irel, *re_irel;
11288
11289 irelend = internal_relocs + sec->reloc_count;
11290
11291 re_irel =
11292 find_relocs_at_address_addr (irel, internal_relocs, irelend,
11293 R_NDS32_PTR_RESOLVED, irel->r_addend);
11294
11295 if (re_irel == irelend)
11296 {
11297 _bfd_error_handler
11298 ("%B: warning: R_NDS32_PTR points to unrecognized reloc at 0x%lx.",
11299 abfd, (long) irel->r_offset);
11300 return FALSE;
11301 }
11302
11303 if (re_irel->r_addend != 1)
11304 return FALSE;
11305
11306 /* Pointed target is relaxed and no longer needs this void *,
11307 change the type to NONE. */
11308 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11309
11310 /* Find PTR_COUNT to decide remove it or not. If PTR_COUNT does
11311 not exist, it means only count 1 and remove it directly. */
11312 /* TODO: I hope we can obsolate R_NDS32_COUNT in the future. */
11313 count_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11314 R_NDS32_PTR_COUNT);
11315 ptr_irel = find_relocs_at_address (irel, internal_relocs, irelend,
11316 R_NDS32_PTR);
11317 if (count_irel != irelend)
11318 {
11319 if (--count_irel->r_addend > 0)
11320 return FALSE;
11321 }
11322
11323 if (ptr_irel != irelend)
11324 return FALSE;
11325
11326 /* If the PTR_COUNT is already 0, remove current instruction. */
11327 *seq_len = nds32_elf_insn_size (abfd, contents, irel->r_offset);
11328 *insn_len = 0;
11329 return TRUE;
11330 }
11331
11332 /* Relax PLT_GOT_SUFF relocation for nds32_elf_relax_section. */
11333
11334 static void
11335 nds32_elf_relax_pltgot_suff (struct bfd_link_info *link_info, bfd *abfd,
11336 asection *sec, Elf_Internal_Rela *irel,
11337 Elf_Internal_Rela *internal_relocs,
11338 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11339 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11340 {
11341 uint32_t insn;
11342 bfd_signed_vma foff;
11343 Elf_Internal_Rela *i1_irelfn, *irelend;
11344 bfd_vma local_sda, laddr;
11345
11346 irelend = internal_relocs + sec->reloc_count;
11347 laddr = irel->r_offset;
11348 insn = bfd_getb32 (contents + laddr);
11349
11350 /* FIXME: It's a little trouble to turn JRAL5 to JAL since
11351 we need additional space. It might be help if we could
11352 borrow some space from instructions to be eliminated
11353 such as sethi, ori, add. */
11354 if (insn & 0x80000000)
11355 return;
11356
11357 if (nds32_elf_check_dup_relocs
11358 (irel, internal_relocs, irelend, R_NDS32_PLT_GOT_SUFF))
11359 return;
11360
11361 i1_irelfn =
11362 find_relocs_at_address (irel, internal_relocs, irelend,
11363 R_NDS32_PTR_RESOLVED);
11364
11365 /* FIXIT 090606
11366 The boundary should be reduced since the .plt section hasn't
11367 been created and the address of specific entry is still unknown
11368 Maybe the range between the function call and the begin of the
11369 .text section can be used to decide if the .plt is in the range
11370 of function call. */
11371
11372 if (N32_OP6 (insn) == N32_OP6_ALU1
11373 && N32_SUB5 (insn) == N32_ALU1_ADD)
11374 {
11375 /* Get the value of the symbol referred to by the reloc. */
11376 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11377 &local_sda, FALSE);
11378 foff = (bfd_signed_vma) (calculate_plt_memory_address
11379 (abfd, link_info, isymbuf, irel,
11380 symtab_hdr) - local_sda);
11381 /* This condition only happened when symbol is undefined. */
11382 if (foff == 0)
11383 return;
11384
11385 if (foff < -CONSERVATIVE_19BIT || foff >= CONSERVATIVE_19BIT)
11386 return;
11387 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11388 R_NDS32_PLT_GOTREL_LO19);
11389 /* addi.gp */
11390 insn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
11391 }
11392 else if (N32_OP6 (insn) == N32_OP6_JREG
11393 && N32_SUB5 (insn) == N32_JREG_JRAL)
11394 {
11395 /* Get the value of the symbol referred to by the reloc. */
11396 foff =
11397 calculate_plt_offset (abfd, sec, link_info, isymbuf, irel, symtab_hdr);
11398 /* This condition only happened when symbol is undefined. */
11399 if (foff == 0)
11400 return;
11401 if (foff < -CONSERVATIVE_24BIT_S1 || foff >= CONSERVATIVE_24BIT_S1)
11402 return;
11403 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_25_PLTREL);
11404 insn = INSN_JAL;
11405 }
11406 else
11407 return;
11408
11409 bfd_putb32 (insn, contents + laddr);
11410 if (i1_irelfn != irelend)
11411 {
11412 i1_irelfn->r_addend |= 1;
11413 *again = TRUE;
11414 }
11415 }
11416
11417 /* Relax GOT_SUFF relocation for nds32_elf_relax_section. */
11418
11419 static void
11420 nds32_elf_relax_got_suff (struct bfd_link_info *link_info, bfd *abfd,
11421 asection *sec, Elf_Internal_Rela *irel,
11422 Elf_Internal_Rela *internal_relocs,
11423 bfd_byte *contents, Elf_Internal_Shdr *symtab_hdr,
11424 bfd_boolean *again)
11425 {
11426 uint32_t insn;
11427 bfd_signed_vma foff;
11428 Elf_Internal_Rela *i1_irelfn, *irelend;
11429 bfd_vma local_sda, laddr;
11430
11431 irelend = internal_relocs + sec->reloc_count;
11432 laddr = irel->r_offset;
11433 insn = bfd_getb32 (contents + laddr);
11434 if (insn & 0x80000000)
11435 return;
11436
11437 if (nds32_elf_check_dup_relocs
11438 (irel, internal_relocs, irelend, R_NDS32_GOT_SUFF))
11439 return;
11440
11441 i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11442 R_NDS32_PTR_RESOLVED);
11443
11444 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11445 &local_sda, FALSE);
11446 foff = calculate_got_memory_address (abfd, link_info, irel,
11447 symtab_hdr) - local_sda;
11448
11449 if (foff < CONSERVATIVE_19BIT && foff >= -CONSERVATIVE_19BIT)
11450 {
11451 /* Turn LW to LWI.GP. Change relocation type to R_NDS32_GOT_REL. */
11452 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
11453 irel->r_info =
11454 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_GOT17S2_RELA);
11455 bfd_putb32 (insn, contents + laddr);
11456 if (i1_irelfn != irelend)
11457 {
11458 i1_irelfn->r_addend |= 1;
11459 *again = TRUE;
11460 }
11461 }
11462 }
11463
11464 /* Relax PLT_GOT_SUFF relocation for nds32_elf_relax_section. */
11465
11466 static void
11467 nds32_elf_relax_gotoff_suff (struct bfd_link_info *link_info, bfd *abfd,
11468 asection *sec, Elf_Internal_Rela *irel,
11469 Elf_Internal_Rela *internal_relocs,
11470 bfd_byte *contents, Elf_Internal_Sym *isymbuf,
11471 Elf_Internal_Shdr *symtab_hdr, bfd_boolean *again)
11472 {
11473 int opc_insn_gotoff;
11474 uint32_t insn;
11475 bfd_signed_vma foff;
11476 Elf_Internal_Rela *i1_irelfn, *i2_irelfn, *irelend;
11477 bfd_vma local_sda, laddr;
11478
11479 irelend = internal_relocs + sec->reloc_count;
11480 laddr = irel->r_offset;
11481 insn = bfd_getb32 (contents + laddr);
11482
11483 if (insn & 0x80000000)
11484 return;
11485
11486 if (nds32_elf_check_dup_relocs
11487 (irel, internal_relocs, irelend, R_NDS32_GOTOFF_SUFF))
11488 return;
11489
11490 i1_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11491 R_NDS32_PTR_RESOLVED);
11492 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
11493 &local_sda, FALSE);
11494 foff = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
11495 foff = foff - local_sda;
11496
11497 if (foff >= CONSERVATIVE_19BIT || foff < -CONSERVATIVE_19BIT)
11498 return;
11499
11500 /* Concatenate opcode and sub-opcode for switch case.
11501 It may be MEM or ALU1. */
11502 opc_insn_gotoff = (N32_OP6 (insn) << 8) | (insn & 0xff);
11503 switch (opc_insn_gotoff)
11504 {
11505 case (N32_OP6_MEM << 8) | N32_MEM_LW:
11506 /* 4-byte aligned. */
11507 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (6, 17, 3));
11508 irel->r_info =
11509 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA17S2_RELA);
11510 break;
11511 case (N32_OP6_MEM << 8) | N32_MEM_SW:
11512 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __MF (7, 17, 3));
11513 irel->r_info =
11514 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA17S2_RELA);
11515 break;
11516 case (N32_OP6_MEM << 8) | N32_MEM_LH:
11517 /* 2-byte aligned. */
11518 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), 0);
11519 irel->r_info =
11520 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11521 break;
11522 case (N32_OP6_MEM << 8) | N32_MEM_LHS:
11523 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (18));
11524 irel->r_info =
11525 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11526 break;
11527 case (N32_OP6_MEM << 8) | N32_MEM_SH:
11528 insn = N32_TYPE1 (HWGP, N32_RT5 (insn), __BIT (19));
11529 irel->r_info =
11530 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA18S1_RELA);
11531 break;
11532 case (N32_OP6_MEM << 8) | N32_MEM_LB:
11533 /* 1-byte aligned. */
11534 insn = N32_TYPE1 (LBGP, N32_RT5 (insn), 0);
11535 irel->r_info =
11536 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11537 break;
11538 case (N32_OP6_MEM << 8) | N32_MEM_LBS:
11539 insn = N32_TYPE1 (LBGP, N32_RT5 (insn), __BIT (19));
11540 irel->r_info =
11541 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11542 break;
11543 case (N32_OP6_MEM << 8) | N32_MEM_SB:
11544 insn = N32_TYPE1 (SBGP, N32_RT5 (insn), 0);
11545 irel->r_info =
11546 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11547 break;
11548 case (N32_OP6_ALU1 << 8) | N32_ALU1_ADD:
11549 insn = N32_TYPE1 (SBGP, N32_RT5 (insn), __BIT (19));
11550 irel->r_info =
11551 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_SDA19S0_RELA);
11552 break;
11553 default:
11554 return;
11555 }
11556
11557 bfd_putb32 (insn, contents + laddr);
11558 if (i1_irelfn != irelend)
11559 {
11560 i1_irelfn->r_addend |= 1;
11561 *again = TRUE;
11562 }
11563 if ((i2_irelfn = find_relocs_at_address (irel, internal_relocs, irelend,
11564 R_NDS32_INSN16)) != irelend)
11565 i2_irelfn->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11566
11567 }
11568
11569 static bfd_boolean
11570 nds32_relax_adjust_label (bfd *abfd, asection *sec,
11571 Elf_Internal_Rela *internal_relocs,
11572 bfd_byte *contents,
11573 nds32_elf_blank_t **relax_blank_list,
11574 int optimize, int opt_size)
11575 {
11576 /* This code block is used to adjust 4-byte alignment by relax a pair
11577 of instruction a time.
11578
11579 It recognizes three types of relocations.
11580 1. R_NDS32_LABEL - a aligment.
11581 2. R_NDS32_INSN16 - relax a 32-bit instruction to 16-bit.
11582 3. is_16bit_NOP () - remove a 16-bit instruction. */
11583
11584 /* TODO: It seems currently implementation only support 4-byte aligment.
11585 We should handle any-aligment. */
11586
11587 Elf_Internal_Rela *insn_rel = NULL, *label_rel = NULL, *irel;
11588 Elf_Internal_Rela *tmp_rel, *tmp2_rel = NULL;
11589 Elf_Internal_Rela rel_temp;
11590 Elf_Internal_Rela *irelend;
11591 bfd_vma address;
11592 uint16_t insn16;
11593
11594 /* Checking for branch relaxation relies on the relocations to
11595 be sorted on 'r_offset'. This is not guaranteed so we must sort. */
11596 nds32_insertion_sort (internal_relocs, sec->reloc_count,
11597 sizeof (Elf_Internal_Rela), compar_reloc);
11598
11599 irelend = internal_relocs + sec->reloc_count;
11600
11601 /* Force R_NDS32_LABEL before R_NDS32_INSN16. */
11602 /* FIXME: Can we generate the right order in assembler?
11603 So we don't have to swapping them here. */
11604
11605 for (label_rel = internal_relocs, insn_rel = internal_relocs;
11606 label_rel < irelend; label_rel++)
11607 {
11608 if (ELF32_R_TYPE (label_rel->r_info) != R_NDS32_LABEL)
11609 continue;
11610
11611 /* Find the first reloc has the same offset with label_rel. */
11612 while (insn_rel < irelend && insn_rel->r_offset < label_rel->r_offset)
11613 insn_rel++;
11614
11615 for (;insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset;
11616 insn_rel++)
11617 /* Check if there were R_NDS32_INSN16 and R_NDS32_LABEL at the same
11618 address. */
11619 if (ELF32_R_TYPE (insn_rel->r_info) == R_NDS32_INSN16)
11620 break;
11621
11622 if (insn_rel < irelend && insn_rel->r_offset == label_rel->r_offset
11623 && insn_rel < label_rel)
11624 {
11625 /* Swap the two reloc if the R_NDS32_INSN16 is
11626 before R_NDS32_LABEL. */
11627 memcpy (&rel_temp, insn_rel, sizeof (Elf_Internal_Rela));
11628 memcpy (insn_rel, label_rel, sizeof (Elf_Internal_Rela));
11629 memcpy (label_rel, &rel_temp, sizeof (Elf_Internal_Rela));
11630 }
11631 }
11632
11633 label_rel = NULL;
11634 insn_rel = NULL;
11635 /* If there were a sequence of R_NDS32_LABEL end up with .align 2
11636 or higher, remove other R_NDS32_LABEL with lower alignment.
11637 If an R_NDS32_INSN16 in between R_NDS32_LABELs must be converted,
11638 then the R_NDS32_LABEL sequence is broke. */
11639 for (tmp_rel = internal_relocs; tmp_rel < irelend; tmp_rel++)
11640 {
11641 if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_LABEL)
11642 {
11643 if (label_rel == NULL)
11644 {
11645 if (tmp_rel->r_addend < 2)
11646 label_rel = tmp_rel;
11647 continue;
11648 }
11649 else if (tmp_rel->r_addend > 1)
11650 {
11651 /* Remove all LABEL relocation from label_rel to tmp_rel
11652 including relocations with same offset as tmp_rel. */
11653 for (tmp2_rel = label_rel; tmp2_rel < tmp_rel
11654 || tmp2_rel->r_offset == tmp_rel->r_offset; tmp2_rel++)
11655 {
11656 if (ELF32_R_TYPE (tmp2_rel->r_info) == R_NDS32_LABEL
11657 && tmp2_rel->r_addend < 2)
11658 tmp2_rel->r_info =
11659 ELF32_R_INFO (ELF32_R_SYM (tmp2_rel->r_info),
11660 R_NDS32_NONE);
11661 }
11662 label_rel = NULL;
11663 }
11664 }
11665 else if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16 && label_rel)
11666 {
11667 /* A new INSN16 which can be converted, so clear label_rel. */
11668 if (is_convert_32_to_16 (abfd, sec, tmp_rel, internal_relocs,
11669 irelend, &insn16)
11670 || is_16bit_NOP (abfd, sec, tmp_rel))
11671 label_rel = NULL;
11672 }
11673 }
11674
11675 label_rel = NULL;
11676 insn_rel = NULL;
11677 /* Optimized for speed and nothing has not been relaxed.
11678 It's time to align labels.
11679 We may convert a 16-bit instruction right before a label to
11680 32-bit, in order to align the label if necessary
11681 all reloc entries has been sorted by r_offset. */
11682 for (irel = internal_relocs; irel < irelend; irel++)
11683 {
11684 if (ELF32_R_TYPE (irel->r_info) != R_NDS32_INSN16
11685 && ELF32_R_TYPE (irel->r_info) != R_NDS32_LABEL)
11686 continue;
11687
11688 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_INSN16)
11689 {
11690 /* A new INSN16 found, resize the old one. */
11691 if (is_convert_32_to_16
11692 (abfd, sec, irel, internal_relocs, irelend, &insn16)
11693 || is_16bit_NOP (abfd, sec, irel))
11694 {
11695 if (insn_rel)
11696 {
11697 /* Previous INSN16 reloc exists, reduce its
11698 size to 16-bit. */
11699 if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
11700 irelend, &insn16))
11701 {
11702 nds32_elf_write_16 (abfd, contents, insn_rel,
11703 internal_relocs, irelend, insn16);
11704
11705 if (!insert_nds32_elf_blank_recalc_total
11706 (relax_blank_list, insn_rel->r_offset + 2, 2))
11707 return FALSE;
11708 }
11709 else if (is_16bit_NOP (abfd, sec, insn_rel))
11710 {
11711 if (!insert_nds32_elf_blank_recalc_total
11712 (relax_blank_list, insn_rel->r_offset, 2))
11713 return FALSE;
11714 }
11715 insn_rel->r_info =
11716 ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info), R_NDS32_NONE);
11717 }
11718 /* Save the new one for later use. */
11719 insn_rel = irel;
11720 }
11721 else
11722 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
11723 R_NDS32_NONE);
11724 }
11725 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL)
11726 {
11727 /* Search for label. */
11728 int force_relax = 0;
11729
11730 /* Label on 16-bit instruction or optimization
11731 needless, just reset this reloc. */
11732 insn16 = bfd_getb16 (contents + irel->r_offset);
11733 if ((irel->r_addend & 0x1f) < 2 && (!optimize || (insn16 & 0x8000)))
11734 {
11735 irel->r_info =
11736 ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_NDS32_NONE);
11737 continue;
11738 }
11739
11740 address =
11741 irel->r_offset - get_nds32_elf_blank_total (relax_blank_list,
11742 irel->r_offset, 1);
11743
11744 if (!insn_rel)
11745 {
11746 /* Check if there is case which can not be aligned. */
11747 if (irel->r_addend == 2 && address & 0x2)
11748 return FALSE;
11749 continue;
11750 }
11751
11752 /* Try to align this label. */
11753
11754 if ((irel->r_addend & 0x1f) < 2)
11755 {
11756 /* Check if there is a INSN16 at the same address.
11757 Label_rel always seats before insn_rel after
11758 our sort. */
11759
11760 /* Search for INSN16 at LABEL location. If INSN16 is at
11761 same location and this LABEL alignment is lower than 2,
11762 the INSN16 can be converted to 2-byte. */
11763 for (tmp_rel = irel;
11764 tmp_rel < irelend && tmp_rel->r_offset == irel->r_offset;
11765 tmp_rel++)
11766 {
11767 if (ELF32_R_TYPE (tmp_rel->r_info) == R_NDS32_INSN16
11768 && (is_convert_32_to_16
11769 (abfd, sec, tmp_rel, internal_relocs,
11770 irelend, &insn16)
11771 || is_16bit_NOP (abfd, sec, tmp_rel)))
11772 {
11773 force_relax = 1;
11774 break;
11775 }
11776 }
11777 }
11778
11779 if (force_relax || irel->r_addend == 1 || address & 0x2)
11780 {
11781 /* Label not aligned. */
11782 /* Previous reloc exists, reduce its size to 16-bit. */
11783 if (is_convert_32_to_16 (abfd, sec, insn_rel,
11784 internal_relocs, irelend, &insn16))
11785 {
11786 nds32_elf_write_16 (abfd, contents, insn_rel,
11787 internal_relocs, irelend, insn16);
11788
11789 if (!insert_nds32_elf_blank_recalc_total
11790 (relax_blank_list, insn_rel->r_offset + 2, 2))
11791 return FALSE;
11792 }
11793 else if (is_16bit_NOP (abfd, sec, insn_rel))
11794 {
11795 if (!insert_nds32_elf_blank_recalc_total
11796 (relax_blank_list, insn_rel->r_offset, 2))
11797 return FALSE;
11798 }
11799
11800 }
11801 /* INSN16 reloc is used. */
11802 insn_rel = NULL;
11803 }
11804 }
11805
11806 address =
11807 sec->size - get_nds32_elf_blank_total (relax_blank_list, sec->size, 0);
11808 if (insn_rel && (address & 0x2 || opt_size))
11809 {
11810 if (is_convert_32_to_16 (abfd, sec, insn_rel, internal_relocs,
11811 irelend, &insn16))
11812 {
11813 nds32_elf_write_16 (abfd, contents, insn_rel, internal_relocs,
11814 irelend, insn16);
11815 if (!insert_nds32_elf_blank_recalc_total
11816 (relax_blank_list, insn_rel->r_offset + 2, 2))
11817 return FALSE;
11818 insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
11819 R_NDS32_NONE);
11820 }
11821 else if (is_16bit_NOP (abfd, sec, insn_rel))
11822 {
11823 if (!insert_nds32_elf_blank_recalc_total
11824 (relax_blank_list, insn_rel->r_offset, 2))
11825 return FALSE;
11826 insn_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (insn_rel->r_info),
11827 R_NDS32_NONE);
11828 }
11829 }
11830 insn_rel = NULL;
11831 return TRUE;
11832 }
11833
11834 /* Pick relaxation round. */
11835
11836 static int
11837 nds32_elf_pick_relax (bfd_boolean init, asection *sec, bfd_boolean *again,
11838 struct elf_nds32_link_hash_table *table,
11839 struct bfd_link_info *link_info)
11840 {
11841 static asection *final_sec, *first_sec = NULL;
11842 static bfd_boolean normal_again = FALSE;
11843 static bfd_boolean set = FALSE;
11844 static bfd_boolean first = TRUE;
11845 int round_table[] = {
11846 NDS32_RELAX_NORMAL_ROUND,
11847 NDS32_RELAX_JUMP_IFC_ROUND,
11848 NDS32_RELAX_EX9_BUILD_ROUND,
11849 NDS32_RELAX_EX9_REPLACE_ROUND,
11850 };
11851 static int pass = 0;
11852 static int relax_round;
11853
11854 /* The new round. */
11855 if (init && first_sec == sec)
11856 {
11857 set = TRUE;
11858 normal_again = FALSE;
11859 }
11860
11861 if (first)
11862 {
11863 /* Run an empty run to get the final section. */
11864 relax_round = NDS32_RELAX_EMPTY_ROUND;
11865
11866 /* It has to enter relax again because we can
11867 not make sure what the final turn is. */
11868 *again = TRUE;
11869
11870 first = FALSE;
11871 first_sec = sec;
11872 }
11873
11874 if (!set)
11875 {
11876 /* Not reenter yet. */
11877 final_sec = sec;
11878 return relax_round;
11879 }
11880
11881 relax_round = round_table[pass];
11882
11883 if (!init && relax_round == NDS32_RELAX_NORMAL_ROUND && *again)
11884 normal_again = TRUE;
11885
11886 if (!init && final_sec == sec)
11887 {
11888 switch (relax_round)
11889 {
11890 case NDS32_RELAX_NORMAL_ROUND:
11891 if (!normal_again)
11892 {
11893 /* Normal relaxation done. */
11894 if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
11895 {
11896 pass++;
11897 *again = TRUE;
11898 }
11899 else if (table->target_optimize & NDS32_RELAX_EX9_ON)
11900 {
11901 pass += 2; /* NDS32_RELAX_EX9_BUILD_ROUND */
11902 *again = TRUE;
11903 }
11904 else if (table->ex9_import_file)
11905 {
11906 /* Import ex9 table. */
11907 if (table->update_ex9_table)
11908 pass += 2; /* NDS32_RELAX_EX9_BUILD_ROUND */
11909 else
11910 pass += 3; /* NDS32_RELAX_EX9_REPLACE_ROUND */
11911 nds32_elf_ex9_import_table (link_info);
11912 *again = TRUE;
11913 }
11914 }
11915 break;
11916 case NDS32_RELAX_JUMP_IFC_ROUND:
11917 if (!nds32_elf_ifc_finish (link_info))
11918 _bfd_error_handler (_("error: Jump IFC Fail."));
11919 if (table->target_optimize & NDS32_RELAX_EX9_ON)
11920 {
11921 pass++;
11922 *again = TRUE;
11923 }
11924 break;
11925 case NDS32_RELAX_EX9_BUILD_ROUND:
11926 nds32_elf_ex9_finish (link_info);
11927 pass++;
11928 *again = TRUE;
11929 break;
11930 case NDS32_RELAX_EX9_REPLACE_ROUND:
11931 if (table->target_optimize & NDS32_RELAX_JUMP_IFC_ON)
11932 {
11933 /* Do jump IFC optimization again. */
11934 if (!nds32_elf_ifc_finish (link_info))
11935 _bfd_error_handler (_("error: Jump IFC Fail."));
11936 }
11937 break;
11938 default:
11939 break;
11940 }
11941 }
11942
11943 return relax_round;
11944 }
11945
11946 static bfd_boolean
11947 nds32_elf_relax_section (bfd *abfd, asection *sec,
11948 struct bfd_link_info *link_info, bfd_boolean *again)
11949 {
11950 nds32_elf_blank_t *relax_blank_list = NULL;
11951 Elf_Internal_Shdr *symtab_hdr;
11952 Elf_Internal_Rela *internal_relocs;
11953 Elf_Internal_Rela *irel;
11954 Elf_Internal_Rela *irelend;
11955 Elf_Internal_Sym *isymbuf = NULL;
11956 bfd_byte *contents = NULL;
11957 bfd_boolean result = TRUE;
11958 int optimize = 0;
11959 int opt_size = 0;
11960 uint32_t insn;
11961 uint16_t insn16;
11962
11963 /* Target dependnet option. */
11964 struct elf_nds32_link_hash_table *table;
11965 int load_store_relax;
11966 int relax_round;
11967
11968 relax_blank_list = NULL;
11969
11970 *again = FALSE;
11971
11972 /* Nothing to do for
11973 * relocatable link or
11974 * non-relocatable section or
11975 * non-code section or
11976 * empty content or
11977 * no reloc entry. */
11978 if (bfd_link_relocatable (link_info)
11979 || (sec->flags & SEC_RELOC) == 0
11980 || (sec->flags & SEC_EXCLUDE) == 1
11981 || (sec->flags & SEC_CODE) == 0
11982 || sec->size == 0)
11983 return TRUE;
11984
11985 /* 09.12.11 Workaround. */
11986 /* We have to adjust align for R_NDS32_LABEL if needed.
11987 The adjust approach only can fix 2-byte align once. */
11988 if (sec->alignment_power > 2)
11989 return TRUE;
11990
11991 /* The optimization type to do. */
11992
11993 table = nds32_elf_hash_table (link_info);
11994 relax_round = nds32_elf_pick_relax (TRUE, sec, again, table, link_info);
11995 switch (relax_round)
11996 {
11997 case NDS32_RELAX_JUMP_IFC_ROUND:
11998 /* Here is the entrance of ifc jump relaxation. */
11999 if (!nds32_elf_ifc_calc (link_info, abfd, sec))
12000 return FALSE;
12001 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
12002 return TRUE;
12003
12004 case NDS32_RELAX_EX9_BUILD_ROUND:
12005 /* Here is the entrance of ex9 relaxation. There are two pass of
12006 ex9 relaxation. The one is to traverse all instructions and build
12007 the hash table. The other one is to compare instructions and replace
12008 it by ex9.it. */
12009 if (!nds32_elf_ex9_build_hash_table (abfd, sec, link_info))
12010 return FALSE;
12011 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
12012 return TRUE;
12013
12014 case NDS32_RELAX_EX9_REPLACE_ROUND:
12015 if (!nds32_elf_ex9_replace_instruction (link_info, abfd, sec))
12016 return FALSE;
12017 return TRUE;
12018
12019 case NDS32_RELAX_EMPTY_ROUND:
12020 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
12021 return TRUE;
12022
12023 case NDS32_RELAX_NORMAL_ROUND:
12024 default:
12025 if (sec->reloc_count == 0)
12026 return TRUE;
12027 break;
12028 }
12029
12030 /* The begining of general relaxation. */
12031
12032 if (is_SDA_BASE_set == 0)
12033 {
12034 bfd_vma gp;
12035 is_SDA_BASE_set = 1;
12036 nds32_elf_final_sda_base (sec->output_section->owner, link_info,
12037 &gp, FALSE);
12038 relax_range_measurement (abfd);
12039 }
12040
12041 if (is_ITB_BASE_set == 0)
12042 {
12043 /* Set the _ITB_BASE_. */
12044 if (!nds32_elf_ex9_itb_base (link_info))
12045 {
12046 _bfd_error_handler (_("%B: error: Cannot set _ITB_BASE_"), abfd);
12047 bfd_set_error (bfd_error_bad_value);
12048 }
12049 }
12050
12051 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12052 /* Relocations MUST be kept in memory, because relaxation adjust them. */
12053 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
12054 TRUE /* keep_memory */);
12055 if (internal_relocs == NULL)
12056 goto error_return;
12057
12058 irelend = internal_relocs + sec->reloc_count;
12059 irel = find_relocs_at_address (internal_relocs, internal_relocs,
12060 irelend, R_NDS32_RELAX_ENTRY);
12061
12062 if (irel == irelend)
12063 return TRUE;
12064
12065 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY)
12066 {
12067 if (irel->r_addend & R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG)
12068 {
12069 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
12070 return TRUE;
12071 }
12072
12073 if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FLAG)
12074 optimize = 1;
12075
12076 if (irel->r_addend & R_NDS32_RELAX_ENTRY_OPTIMIZE_FOR_SPACE_FLAG)
12077 opt_size = 1;
12078 }
12079
12080 load_store_relax = table->load_store_relax;
12081
12082 /* Get symbol table and section content. */
12083 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12084 || !nds32_get_local_syms (abfd, sec, &isymbuf))
12085 goto error_return;
12086
12087 /* Do relax loop only when finalize is not done.
12088 Take care of relaxable relocs except INSN16. */
12089 for (irel = internal_relocs; irel < irelend; irel++)
12090 {
12091 int seq_len; /* Original length of instruction sequence. */
12092 int insn_len = 0; /* Final length of instruction sequence. */
12093 bfd_boolean removed;
12094
12095 insn = 0;
12096 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
12097 && (irel->r_addend & 0x1f) >= 2)
12098 optimize = 1;
12099
12100 /* Relocation Types
12101 R_NDS32_LONGCALL1 53
12102 R_NDS32_LONGCALL2 54
12103 R_NDS32_LONGCALL3 55
12104 R_NDS32_LONGJUMP1 56
12105 R_NDS32_LONGJUMP2 57
12106 R_NDS32_LONGJUMP3 58
12107 R_NDS32_LOADSTORE 59 */
12108 if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL1
12109 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LOADSTORE)
12110 seq_len = GET_SEQ_LEN (irel->r_addend);
12111
12112 /* Relocation Types
12113 R_NDS32_LONGCALL4 107
12114 R_NDS32_LONGCALL5 108
12115 R_NDS32_LONGCALL6 109
12116 R_NDS32_LONGJUMP4 110
12117 R_NDS32_LONGJUMP5 111
12118 R_NDS32_LONGJUMP6 112
12119 R_NDS32_LONGJUMP7 113 */
12120 else if (ELF32_R_TYPE (irel->r_info) >= R_NDS32_LONGCALL4
12121 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_LONGJUMP7)
12122 seq_len = 4;
12123
12124 /* Relocation Types
12125 R_NDS32_LO12S0_RELA 30
12126 R_NDS32_LO12S1_RELA 29
12127 R_NDS32_LO12S2_RELA 28
12128 R_NDS32_LO12S2_SP_RELA 71
12129 R_NDS32_LO12S2_DP_RELA 70
12130 R_NDS32_GOT_LO12 46
12131 R_NDS32_GOTOFF_LO12 50
12132 R_NDS32_PLTREL_LO12 65
12133 R_NDS32_PLT_GOTREL_LO12 67
12134 R_NDS32_17IFC_PCREL_RELA 96
12135 R_NDS32_GOT_SUFF 193
12136 R_NDS32_GOTOFF_SUFF 194
12137 R_NDS32_PLT_GOT_SUFF 195
12138 R_NDS32_MULCALL_SUFF 196
12139 R_NDS32_PTR 197 */
12140 else if ((ELF32_R_TYPE (irel->r_info) <= R_NDS32_LO12S0_RELA
12141 && ELF32_R_TYPE (irel->r_info) >= R_NDS32_LO12S2_RELA)
12142 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_SP_RELA
12143 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_DP_RELA
12144 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOT_LO12
12145 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTOFF_LO12
12146 || ELF32_R_TYPE (irel->r_info) == R_NDS32_GOTPC_LO12
12147 || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLTREL_LO12
12148 || ELF32_R_TYPE (irel->r_info) == R_NDS32_PLT_GOTREL_LO12
12149 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_GOT_SUFF
12150 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_PTR)
12151 || ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12152 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LO12
12153 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_ADD
12154 || ELF32_R_TYPE (irel->r_info) == R_NDS32_TLS_LE_LS)
12155 seq_len = 0;
12156 else
12157 continue;
12158
12159 insn_len = seq_len;
12160 removed = FALSE;
12161
12162 switch (ELF32_R_TYPE (irel->r_info))
12163 {
12164 case R_NDS32_LONGCALL1:
12165 removed = nds32_elf_relax_longcall1 (abfd, sec, irel, internal_relocs,
12166 &insn_len, contents, isymbuf,
12167 symtab_hdr);
12168 break;
12169 case R_NDS32_LONGCALL2:
12170 removed = nds32_elf_relax_longcall2 (abfd, sec, irel, internal_relocs,
12171 &insn_len, contents, isymbuf,
12172 symtab_hdr);
12173 break;
12174 case R_NDS32_LONGCALL3:
12175 removed = nds32_elf_relax_longcall3 (abfd, sec, irel, internal_relocs,
12176 &insn_len, contents, isymbuf,
12177 symtab_hdr);
12178 break;
12179 case R_NDS32_LONGJUMP1:
12180 removed = nds32_elf_relax_longjump1 (abfd, sec, irel, internal_relocs,
12181 &insn_len, contents, isymbuf,
12182 symtab_hdr);
12183 break;
12184 case R_NDS32_LONGJUMP2:
12185 removed = nds32_elf_relax_longjump2 (abfd, sec, irel, internal_relocs,
12186 &insn_len, contents, isymbuf,
12187 symtab_hdr);
12188 break;
12189 case R_NDS32_LONGJUMP3:
12190 removed = nds32_elf_relax_longjump3 (abfd, sec, irel, internal_relocs,
12191 &insn_len, contents, isymbuf,
12192 symtab_hdr);
12193 break;
12194 case R_NDS32_LONGCALL4:
12195 removed = nds32_elf_relax_longcall4 (abfd, sec, irel, internal_relocs,
12196 &insn_len, contents, isymbuf,
12197 symtab_hdr);
12198 break;
12199 case R_NDS32_LONGCALL5:
12200 removed = nds32_elf_relax_longcall5 (abfd, sec, irel, internal_relocs,
12201 &insn_len, contents, isymbuf,
12202 symtab_hdr);
12203 break;
12204 case R_NDS32_LONGCALL6:
12205 removed = nds32_elf_relax_longcall6 (abfd, sec, irel, internal_relocs,
12206 &insn_len, contents, isymbuf,
12207 symtab_hdr);
12208 break;
12209 case R_NDS32_LONGJUMP4:
12210 removed = nds32_elf_relax_longjump4 (abfd, sec, irel, internal_relocs,
12211 &insn_len, contents, isymbuf,
12212 symtab_hdr);
12213 break;
12214 case R_NDS32_LONGJUMP5:
12215 removed = nds32_elf_relax_longjump5 (abfd, sec, irel, internal_relocs,
12216 &insn_len, &seq_len, contents,
12217 isymbuf, symtab_hdr);
12218 break;
12219 case R_NDS32_LONGJUMP6:
12220 removed = nds32_elf_relax_longjump6 (abfd, sec, irel, internal_relocs,
12221 &insn_len, &seq_len, contents,
12222 isymbuf, symtab_hdr);
12223 break;
12224 case R_NDS32_LONGJUMP7:
12225 removed = nds32_elf_relax_longjump7 (abfd, sec, irel, internal_relocs,
12226 &insn_len, &seq_len, contents,
12227 isymbuf, symtab_hdr);
12228 break;
12229 case R_NDS32_LOADSTORE:
12230 removed = nds32_elf_relax_loadstore (link_info, abfd, sec, irel,
12231 internal_relocs, &insn_len,
12232 contents, isymbuf, symtab_hdr,
12233 load_store_relax);
12234 break;
12235 case R_NDS32_LO12S0_RELA:
12236 case R_NDS32_LO12S1_RELA:
12237 case R_NDS32_LO12S2_DP_RELA:
12238 case R_NDS32_LO12S2_SP_RELA:
12239 case R_NDS32_LO12S2_RELA:
12240 /* Relax for low part. */
12241 nds32_elf_relax_lo12 (link_info, abfd, sec, irel, internal_relocs,
12242 contents, isymbuf, symtab_hdr);
12243
12244 /* It is impossible to delete blank, so just continue. */
12245 continue;
12246 case R_NDS32_GOT_LO12:
12247 case R_NDS32_GOTOFF_LO12:
12248 case R_NDS32_PLTREL_LO12:
12249 case R_NDS32_PLT_GOTREL_LO12:
12250 case R_NDS32_GOTPC_LO12:
12251 /* Relax for PIC gp-relative low part. */
12252 nds32_elf_relax_piclo12 (link_info, abfd, sec, irel, contents,
12253 isymbuf, symtab_hdr);
12254
12255 /* It is impossible to delete blank, so just continue. */
12256 continue;
12257 case R_NDS32_TLS_LE_LO12:
12258 /* Relax for LE TLS low part. */
12259 nds32_elf_relax_letlslo12 (link_info, abfd, irel, contents,
12260 isymbuf, symtab_hdr);
12261
12262 /* It is impossible to delete blank, so just continue. */
12263 continue;
12264 case R_NDS32_TLS_LE_ADD:
12265 nds32_elf_relax_letlsadd (link_info, abfd, sec, irel, internal_relocs,
12266 contents, isymbuf, symtab_hdr, again);
12267 /* It is impossible to delete blank, so just continue. */
12268 continue;
12269 case R_NDS32_TLS_LE_LS:
12270 nds32_elf_relax_letlsls (link_info, abfd, sec, irel, internal_relocs,
12271 contents, isymbuf, symtab_hdr, again);
12272 continue;
12273 case R_NDS32_PTR:
12274 removed = nds32_elf_relax_ptr (abfd, sec, irel, internal_relocs,
12275 &insn_len, &seq_len, contents);
12276 break;
12277 case R_NDS32_PLT_GOT_SUFF:
12278 nds32_elf_relax_pltgot_suff (link_info, abfd, sec, irel,
12279 internal_relocs, contents,
12280 isymbuf, symtab_hdr, again);
12281 /* It is impossible to delete blank, so just continue. */
12282 continue;
12283 case R_NDS32_GOT_SUFF:
12284 nds32_elf_relax_got_suff (link_info, abfd, sec, irel,
12285 internal_relocs, contents,
12286 symtab_hdr, again);
12287 /* It is impossible to delete blank, so just continue. */
12288 continue;
12289 case R_NDS32_GOTOFF_SUFF:
12290 nds32_elf_relax_gotoff_suff (link_info, abfd, sec, irel,
12291 internal_relocs, contents,
12292 isymbuf, symtab_hdr, again);
12293 /* It is impossible to delete blank, so just continue. */
12294 continue;
12295 default:
12296 continue;
12297
12298 }
12299 if (removed && seq_len - insn_len > 0)
12300 {
12301 if (!insert_nds32_elf_blank
12302 (&relax_blank_list, irel->r_offset + insn_len,
12303 seq_len - insn_len))
12304 goto error_return;
12305 *again = TRUE;
12306 }
12307 }
12308
12309 calc_nds32_blank_total (relax_blank_list);
12310
12311 if (table->relax_fp_as_gp)
12312 {
12313 if (!nds32_relax_fp_as_gp (link_info, abfd, sec, internal_relocs,
12314 irelend, isymbuf))
12315 goto error_return;
12316
12317 if (*again == FALSE)
12318 {
12319 if (!nds32_fag_remove_unused_fpbase (abfd, sec, internal_relocs,
12320 irelend))
12321 goto error_return;
12322 }
12323 }
12324
12325 nds32_elf_pick_relax (FALSE, sec, again, table, link_info);
12326
12327 if (*again == FALSE)
12328 {
12329 if (!nds32_relax_adjust_label (abfd, sec, internal_relocs, contents,
12330 &relax_blank_list, optimize, opt_size))
12331 goto error_return;
12332 }
12333
12334 /* It doesn't matter optimize_for_space_no_align anymore.
12335 If object file is assembled with flag '-Os',
12336 the we don't adjust jump-destination on 4-byte boundary. */
12337
12338 if (relax_blank_list)
12339 {
12340 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12341 relax_blank_list = NULL;
12342 }
12343
12344 if (*again == FALSE)
12345 {
12346 /* Closing the section, so we don't relax it anymore. */
12347 bfd_vma sec_size_align;
12348 Elf_Internal_Rela *tmp_rel;
12349
12350 /* Pad to alignment boundary. Only handle current section alignment. */
12351 sec_size_align = (sec->size + (~((-1U) << sec->alignment_power)))
12352 & ((-1U) << sec->alignment_power);
12353 if ((sec_size_align - sec->size) & 0x2)
12354 {
12355 insn16 = NDS32_NOP16;
12356 bfd_putb16 (insn16, contents + sec->size);
12357 sec->size += 2;
12358 }
12359
12360 while (sec_size_align != sec->size)
12361 {
12362 insn = NDS32_NOP32;
12363 bfd_putb32 (insn, contents + sec->size);
12364 sec->size += 4;
12365 }
12366
12367 tmp_rel = find_relocs_at_address (internal_relocs, internal_relocs,
12368 irelend, R_NDS32_RELAX_ENTRY);
12369 if (tmp_rel != irelend)
12370 tmp_rel->r_addend |= R_NDS32_RELAX_ENTRY_DISABLE_RELAX_FLAG;
12371
12372 clean_nds32_elf_blank ();
12373 }
12374
12375 finish:
12376 if (internal_relocs != NULL
12377 && elf_section_data (sec)->relocs != internal_relocs)
12378 free (internal_relocs);
12379
12380 if (contents != NULL
12381 && elf_section_data (sec)->this_hdr.contents != contents)
12382 free (contents);
12383
12384 if (isymbuf != NULL && symtab_hdr->contents != (bfd_byte *) isymbuf)
12385 free (isymbuf);
12386
12387 return result;
12388
12389 error_return:
12390 result = FALSE;
12391 goto finish;
12392 }
12393
12394 static struct bfd_elf_special_section const nds32_elf_special_sections[] =
12395 {
12396 {".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE},
12397 {".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE},
12398 {NULL, 0, 0, 0, 0}
12399 };
12400
12401 static bfd_boolean
12402 nds32_elf_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
12403 struct bfd_link_info *info,
12404 void *finfo ATTRIBUTE_UNUSED,
12405 bfd_boolean (*func) (void *, const char *,
12406 Elf_Internal_Sym *,
12407 asection *,
12408 struct elf_link_hash_entry *)
12409 ATTRIBUTE_UNUSED)
12410 {
12411 FILE *sym_ld_script = NULL;
12412 struct elf_nds32_link_hash_table *table;
12413
12414 table = nds32_elf_hash_table (info);
12415 sym_ld_script = table->sym_ld_script;
12416
12417 if (check_start_export_sym)
12418 fprintf (sym_ld_script, "}\n");
12419
12420 return TRUE;
12421 }
12422
12423 static enum elf_reloc_type_class
12424 nds32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
12425 const asection *rel_sec ATTRIBUTE_UNUSED,
12426 const Elf_Internal_Rela *rela)
12427 {
12428 switch ((int) ELF32_R_TYPE (rela->r_info))
12429 {
12430 case R_NDS32_RELATIVE:
12431 return reloc_class_relative;
12432 case R_NDS32_JMP_SLOT:
12433 return reloc_class_plt;
12434 case R_NDS32_COPY:
12435 return reloc_class_copy;
12436 default:
12437 return reloc_class_normal;
12438 }
12439 }
12440
12441 /* Put target dependent option into info hash table. */
12442 void
12443 bfd_elf32_nds32_set_target_option (struct bfd_link_info *link_info,
12444 int relax_fp_as_gp,
12445 int eliminate_gc_relocs,
12446 FILE * sym_ld_script, int load_store_relax,
12447 int target_optimize, int relax_status,
12448 int relax_round, FILE * ex9_export_file,
12449 FILE * ex9_import_file,
12450 int update_ex9_table, int ex9_limit,
12451 bfd_boolean ex9_loop_aware,
12452 bfd_boolean ifc_loop_aware)
12453 {
12454 struct elf_nds32_link_hash_table *table;
12455
12456 table = nds32_elf_hash_table (link_info);
12457 if (table == NULL)
12458 return;
12459
12460 table->relax_fp_as_gp = relax_fp_as_gp;
12461 table->eliminate_gc_relocs = eliminate_gc_relocs;
12462 table->sym_ld_script = sym_ld_script;
12463 table ->load_store_relax = load_store_relax;
12464 table->target_optimize = target_optimize;
12465 table->relax_status = relax_status;
12466 table->relax_round = relax_round;
12467 table->ex9_export_file = ex9_export_file;
12468 table->ex9_import_file = ex9_import_file;
12469 table->update_ex9_table = update_ex9_table;
12470 table->ex9_limit = ex9_limit;
12471 table->ex9_loop_aware = ex9_loop_aware;
12472 table->ifc_loop_aware = ifc_loop_aware;
12473 }
12474 \f
12475 /* These functions and data-structures are used for fp-as-gp
12476 optimization. */
12477
12478 #define FAG_THRESHOLD 3 /* At least 3 gp-access. */
12479 /* lwi37.fp covers 508 bytes, but there may be 32-byte padding between
12480 the read-only section and read-write section. */
12481 #define FAG_WINDOW (508 - 32)
12482
12483 /* An nds32_fag represent a gp-relative access.
12484 We find best fp-base by using a sliding window
12485 to find a base address which can cover most gp-access. */
12486 struct nds32_fag
12487 {
12488 struct nds32_fag *next; /* NULL-teminated linked list. */
12489 bfd_vma addr; /* The address of this fag. */
12490 Elf_Internal_Rela **relas; /* The relocations associated with this fag.
12491 It is used for applying FP7U2_FLAG. */
12492 int count; /* How many times this address is referred.
12493 There should be exactly `count' relocations
12494 in relas. */
12495 int relas_capcity; /* The buffer size of relas.
12496 We use an array instead of linked-list,
12497 and realloc is used to adjust buffer size. */
12498 };
12499
12500 static void
12501 nds32_fag_init (struct nds32_fag *head)
12502 {
12503 memset (head, 0, sizeof (struct nds32_fag));
12504 }
12505
12506 static void
12507 nds32_fag_verify (struct nds32_fag *head)
12508 {
12509 struct nds32_fag *iter;
12510 struct nds32_fag *prev;
12511
12512 prev = NULL;
12513 iter = head->next;
12514 while (iter)
12515 {
12516 if (prev && prev->addr >= iter->addr)
12517 puts ("Bug in fp-as-gp insertion.");
12518 prev = iter;
12519 iter = iter->next;
12520 }
12521 }
12522
12523 /* Insert a fag in ascending order.
12524 If a fag of the same address already exists,
12525 they are chained by relas array. */
12526
12527 static void
12528 nds32_fag_insert (struct nds32_fag *head, bfd_vma addr,
12529 Elf_Internal_Rela * rel)
12530 {
12531 struct nds32_fag *iter;
12532 struct nds32_fag *new_fag;
12533 const int INIT_RELAS_CAP = 4;
12534
12535 for (iter = head;
12536 iter->next && iter->next->addr <= addr;
12537 iter = iter->next)
12538 /* Find somewhere to insert. */ ;
12539
12540 /* `iter' will be equal to `head' if the list is empty. */
12541 if (iter != head && iter->addr == addr)
12542 {
12543 /* The address exists in the list.
12544 Insert `rel' into relocation list, relas. */
12545
12546 /* Check whether relas is big enough. */
12547 if (iter->count >= iter->relas_capcity)
12548 {
12549 iter->relas_capcity *= 2;
12550 iter->relas = bfd_realloc
12551 (iter->relas, iter->relas_capcity * sizeof (void *));
12552 }
12553 iter->relas[iter->count++] = rel;
12554 return;
12555 }
12556
12557 /* This is a new address. Create a fag node for it. */
12558 new_fag = bfd_malloc (sizeof (struct nds32_fag));
12559 memset (new_fag, 0, sizeof (*new_fag));
12560 new_fag->addr = addr;
12561 new_fag->count = 1;
12562 new_fag->next = iter->next;
12563 new_fag->relas_capcity = INIT_RELAS_CAP;
12564 new_fag->relas = (Elf_Internal_Rela **)
12565 bfd_malloc (new_fag->relas_capcity * sizeof (void *));
12566 new_fag->relas[0] = rel;
12567 iter->next = new_fag;
12568
12569 nds32_fag_verify (head);
12570 }
12571
12572 static void
12573 nds32_fag_free_list (struct nds32_fag *head)
12574 {
12575 struct nds32_fag *iter;
12576
12577 iter = head->next;
12578 while (iter)
12579 {
12580 struct nds32_fag *tmp = iter;
12581 iter = iter->next;
12582 free (tmp->relas);
12583 tmp->relas = NULL;
12584 free (tmp);
12585 }
12586 }
12587
12588 /* Find the best fp-base address.
12589 The relocation associated with that address is returned,
12590 so we can track the symbol instead of a fixed address.
12591
12592 When relaxation, the address of an datum may change,
12593 because a text section is shrinked, so the data section
12594 moves forward. If the aligments of text and data section
12595 are different, their distance may change too.
12596 Therefore, tracking a fixed address is not appriate. */
12597
12598 static int
12599 nds32_fag_find_base (struct nds32_fag *head, struct nds32_fag **bestpp)
12600 {
12601 struct nds32_fag *base; /* First fag in the window. */
12602 struct nds32_fag *last; /* First fag outside the window. */
12603 int accu = 0; /* Usage accumulation. */
12604 struct nds32_fag *best; /* Best fag. */
12605 int baccu = 0; /* Best accumulation. */
12606
12607 /* Use first fag for initial, and find the last fag in the window.
12608
12609 In each iteration, we could simply subtract previous fag
12610 and accumulate following fags which are inside the window,
12611 untill we each the end. */
12612
12613 if (head->next == NULL)
12614 {
12615 *bestpp = NULL;
12616 return 0;
12617 }
12618
12619 /* Initialize base. */
12620 base = head->next;
12621 best = base;
12622 for (last = base;
12623 last && last->addr < base->addr + FAG_WINDOW;
12624 last = last->next)
12625 accu += last->count;
12626
12627 baccu = accu;
12628
12629 /* Record the best base in each iteration. */
12630 while (base->next)
12631 {
12632 accu -= base->count;
12633 base = base->next;
12634 /* Account fags in window. */
12635 for (/* Nothing. */;
12636 last && last->addr < base->addr + FAG_WINDOW;
12637 last = last->next)
12638 accu += last->count;
12639
12640 /* A better fp-base? */
12641 if (accu > baccu)
12642 {
12643 best = base;
12644 baccu = accu;
12645 }
12646 }
12647
12648 if (bestpp)
12649 *bestpp = best;
12650 return baccu;
12651 }
12652
12653 /* Apply R_NDS32_INSN16_FP7U2_FLAG on gp-relative accesses,
12654 so we can convert it fo fp-relative access later.
12655 `best_fag' is the best fp-base. Only those inside the window
12656 of best_fag is applied the flag. */
12657
12658 static bfd_boolean
12659 nds32_fag_mark_relax (struct bfd_link_info *link_info,
12660 bfd *abfd, struct nds32_fag *best_fag,
12661 Elf_Internal_Rela *internal_relocs,
12662 Elf_Internal_Rela *irelend)
12663 {
12664 struct nds32_fag *ifag;
12665 bfd_vma best_fpbase, gp;
12666 bfd *output_bfd;
12667
12668 output_bfd = abfd->sections->output_section->owner;
12669 nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
12670 best_fpbase = best_fag->addr;
12671
12672 if (best_fpbase > gp + sdata_range[1][1]
12673 || best_fpbase < gp - sdata_range[1][0])
12674 return FALSE;
12675
12676 /* Mark these inside the window R_NDS32_INSN16_FP7U2_FLAG flag,
12677 so we know they can be converted to lwi37.fp. */
12678 for (ifag = best_fag;
12679 ifag && ifag->addr < best_fpbase + FAG_WINDOW; ifag = ifag->next)
12680 {
12681 int i;
12682
12683 for (i = 0; i < ifag->count; i++)
12684 {
12685 Elf_Internal_Rela *insn16_rel;
12686 Elf_Internal_Rela *fag_rel;
12687
12688 fag_rel = ifag->relas[i];
12689
12690 /* Only if this is within the WINDOWS, FP7U2_FLAG
12691 is applied. */
12692
12693 insn16_rel = find_relocs_at_address
12694 (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12695
12696 if (insn16_rel != irelend)
12697 insn16_rel->r_addend = R_NDS32_INSN16_FP7U2_FLAG;
12698 }
12699 }
12700 return TRUE;
12701 }
12702
12703 /* Reset INSN16 to clean fp as gp. */
12704
12705 static void
12706 nds32_fag_unmark_relax (struct nds32_fag *fag,
12707 Elf_Internal_Rela *internal_relocs,
12708 Elf_Internal_Rela *irelend)
12709 {
12710 struct nds32_fag *ifag;
12711 int i;
12712 Elf_Internal_Rela *insn16_rel;
12713 Elf_Internal_Rela *fag_rel;
12714
12715 for (ifag = fag; ifag; ifag = ifag->next)
12716 {
12717 for (i = 0; i < ifag->count; i++)
12718 {
12719 fag_rel = ifag->relas[i];
12720
12721 /* Restore the INSN16 relocation. */
12722 insn16_rel = find_relocs_at_address
12723 (fag_rel, internal_relocs, irelend, R_NDS32_INSN16);
12724
12725 if (insn16_rel != irelend)
12726 insn16_rel->r_addend &= ~R_NDS32_INSN16_FP7U2_FLAG;
12727 }
12728 }
12729 }
12730
12731 /* This is the main function of fp-as-gp optimization.
12732 It should be called by relax_section. */
12733
12734 static bfd_boolean
12735 nds32_relax_fp_as_gp (struct bfd_link_info *link_info,
12736 bfd *abfd, asection *sec,
12737 Elf_Internal_Rela *internal_relocs,
12738 Elf_Internal_Rela *irelend,
12739 Elf_Internal_Sym *isymbuf)
12740 {
12741 Elf_Internal_Rela *begin_rel = NULL;
12742 Elf_Internal_Rela *irel;
12743 struct nds32_fag fag_head;
12744 Elf_Internal_Shdr *symtab_hdr;
12745 bfd_byte *contents;
12746 bfd_boolean ifc_inside = FALSE;
12747
12748 /* FIXME: Can we bfd_elf_link_read_relocs for the relocs? */
12749
12750 /* Per-function fp-base selection.
12751 1. Create a list for all the gp-relative access.
12752 2. Base on those gp-relative address,
12753 find a fp-base which can cover most access.
12754 3. Use the fp-base for fp-as-gp relaxation.
12755
12756 NOTE: If fp-as-gp is not worth to do, (e.g., less than 3 times),
12757 we should
12758 1. delete the `la $fp, _FP_BASE_' instruction and
12759 2. not convert lwi.gp to lwi37.fp.
12760
12761 To delete the _FP_BASE_ instruction, we simply apply
12762 R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG flag in the r_addend to disable it.
12763
12764 To suppress the conversion, we simply NOT to apply
12765 R_NDS32_INSN16_FP7U2_FLAG flag. */
12766
12767 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12768
12769 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
12770 || !nds32_get_local_syms (abfd, sec, &isymbuf))
12771 return FALSE;
12772
12773 /* Check whether it is worth for fp-as-gp optimization,
12774 i.e., at least 3 gp-load.
12775
12776 Set R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG if we should NOT
12777 apply this optimization. */
12778
12779 for (irel = internal_relocs; irel < irelend; irel++)
12780 {
12781 /* We recognize R_NDS32_RELAX_REGION_BEGIN/_END for the region.
12782 One we enter the begin of the region, we track all the LW/ST
12783 instructions, so when we leave the region, we try to find
12784 the best fp-base address for those LW/ST instructions. */
12785
12786 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12787 && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12788 {
12789 /* Begin of the region. */
12790 if (begin_rel)
12791 _bfd_error_handler (_("%B: Nested OMIT_FP in %A."), abfd, sec);
12792
12793 begin_rel = irel;
12794 nds32_fag_init (&fag_head);
12795 ifc_inside = FALSE;
12796 }
12797 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
12798 && (irel->r_addend & R_NDS32_RELAX_REGION_OMIT_FP_FLAG))
12799 {
12800 int accu;
12801 struct nds32_fag *best_fag, *tmp_fag;
12802 int dist;
12803
12804 /* End of the region.
12805 Check whether it is worth to do fp-as-gp. */
12806
12807 if (begin_rel == NULL)
12808 {
12809 _bfd_error_handler (_("%B: Unmatched OMIT_FP in %A."), abfd, sec);
12810 continue;
12811 }
12812
12813 accu = nds32_fag_find_base (&fag_head, &best_fag);
12814
12815 /* Clean FP7U2_FLAG because they may set ever. */
12816 tmp_fag = fag_head.next;
12817 nds32_fag_unmark_relax (tmp_fag, internal_relocs, irelend);
12818
12819 /* Check if it is worth, and FP_BASE is near enough to SDA_BASE. */
12820 if (accu < FAG_THRESHOLD
12821 || !nds32_fag_mark_relax (link_info, abfd, best_fag,
12822 internal_relocs, irelend))
12823 {
12824 /* Not worth to do fp-as-gp. */
12825 begin_rel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
12826 begin_rel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
12827 irel->r_addend |= R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG;
12828 irel->r_addend &= ~R_NDS32_RELAX_REGION_OMIT_FP_FLAG;
12829 nds32_fag_free_list (&fag_head);
12830 begin_rel = NULL;
12831 continue;
12832 }
12833
12834 /* R_SYM of R_NDS32_RELAX_REGION_BEGIN is not used by assembler,
12835 so we use it to record the distance to the reloction of best
12836 fp-base. */
12837 dist = best_fag->relas[0] - begin_rel;
12838 BFD_ASSERT (dist > 0 && dist < 0xffffff);
12839 /* Use high 16 bits of addend to record the _FP_BASE_ matched
12840 relocation. And get the base value when relocating. */
12841 begin_rel->r_addend &= (0x1 << 16) - 1;
12842 begin_rel->r_addend |= dist << 16;
12843
12844 nds32_fag_free_list (&fag_head);
12845 begin_rel = NULL;
12846 }
12847
12848 if (begin_rel == NULL || ifc_inside)
12849 /* Skip if we are not in the region of fp-as-gp. */
12850 continue;
12851
12852 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S2_RELA
12853 || ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA17S2_RELA)
12854 {
12855 bfd_vma addr;
12856 uint32_t insn;
12857
12858 /* A gp-relative access is found. Insert it to the fag-list. */
12859
12860 /* Rt is necessary an RT3, so it can be converted to lwi37.fp. */
12861 insn = bfd_getb32 (contents + irel->r_offset);
12862 if (!N32_IS_RT3 (insn))
12863 continue;
12864
12865 addr = calculate_memory_address (abfd, irel, isymbuf, symtab_hdr);
12866 nds32_fag_insert (&fag_head, addr, irel);
12867 }
12868 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA_FP7U2_RELA)
12869 {
12870 begin_rel = NULL;
12871 }
12872 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_17IFC_PCREL_RELA
12873 || ELF32_R_TYPE (irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
12874 {
12875 /* Suppress fp as gp when encounter ifc. */
12876 ifc_inside = TRUE;
12877 }
12878 }
12879
12880 return TRUE;
12881 }
12882
12883 /* Remove unused `la $fp, _FD_BASE_' instruction. */
12884
12885 static bfd_boolean
12886 nds32_fag_remove_unused_fpbase (bfd *abfd, asection *sec,
12887 Elf_Internal_Rela *internal_relocs,
12888 Elf_Internal_Rela *irelend)
12889 {
12890 Elf_Internal_Rela *irel;
12891 Elf_Internal_Shdr *symtab_hdr;
12892 bfd_byte *contents = NULL;
12893 nds32_elf_blank_t *relax_blank_list = NULL;
12894 bfd_boolean result = TRUE;
12895 bfd_boolean unused_region = FALSE;
12896
12897 /*
12898 NOTE: Disable fp-as-gp if we encounter ifcall relocations.
12899 * R_NDS32_17IFC_PCREL_RELA
12900 * R_NDS32_10IFCU_PCREL_RELA
12901
12902 CASE??????????????
12903 */
12904
12905 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12906 nds32_get_section_contents (abfd, sec, &contents, TRUE);
12907
12908 for (irel = internal_relocs; irel < irelend; irel++)
12909 {
12910 /* To remove unused fp-base, we simply find the REGION_NOT_OMIT_FP
12911 we marked to in previous pass.
12912 DO NOT scan relocations again, since we've alreadly decided it
12913 and set the flag. */
12914 const char *syname;
12915 int syndx;
12916 uint32_t insn;
12917
12918 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
12919 && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
12920 unused_region = TRUE;
12921 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
12922 && (irel->r_addend & R_NDS32_RELAX_REGION_NOT_OMIT_FP_FLAG))
12923 unused_region = FALSE;
12924
12925 /* We're not in the region. */
12926 if (!unused_region)
12927 continue;
12928
12929 /* _FP_BASE_ must be a GLOBAL symbol. */
12930 syndx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
12931 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
12932 continue;
12933
12934 /* The symbol name must be _FP_BASE_. */
12935 syname = elf_sym_hashes (abfd)[syndx]->root.root.string;
12936 if (strcmp (syname, FP_BASE_NAME) != 0)
12937 continue;
12938
12939 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA19S0_RELA)
12940 {
12941 /* addi.gp $fp, -256 */
12942 insn = bfd_getb32 (contents + irel->r_offset);
12943 if (insn != INSN_ADDIGP_TO_FP)
12944 continue;
12945 }
12946 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_SDA15S0_RELA)
12947 {
12948 /* addi $fp, $gp, -256 */
12949 insn = bfd_getb32 (contents + irel->r_offset);
12950 if (insn != INSN_ADDI_GP_TO_FP)
12951 continue;
12952 }
12953 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_20_RELA)
12954 {
12955 /* movi $fp, FP_BASE */
12956 insn = bfd_getb32 (contents + irel->r_offset);
12957 if (insn != INSN_MOVI_TO_FP)
12958 continue;
12959 }
12960 else
12961 continue;
12962
12963 /* We got here because a FP_BASE instruction is found. */
12964 if (!insert_nds32_elf_blank_recalc_total
12965 (&relax_blank_list, irel->r_offset, 4))
12966 goto error_return;
12967 }
12968
12969 finish:
12970 if (relax_blank_list)
12971 {
12972 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
12973 relax_blank_list = NULL;
12974 }
12975 return result;
12976
12977 error_return:
12978 result = FALSE;
12979 goto finish;
12980 }
12981
12982 /* This is a version of bfd_generic_get_relocated_section_contents.
12983 We need this variety because relaxation will modify the dwarf
12984 infomation. When there is undefined symbol reference error mesage,
12985 linker need to dump line number where the symbol be used. However
12986 the address is be relaxed, it can not get the original dwarf contents.
12987 The variety only modify function call for reading in the section. */
12988
12989 static bfd_byte *
12990 nds32_elf_get_relocated_section_contents (bfd *abfd,
12991 struct bfd_link_info *link_info,
12992 struct bfd_link_order *link_order,
12993 bfd_byte *data,
12994 bfd_boolean relocatable,
12995 asymbol **symbols)
12996 {
12997 bfd *input_bfd = link_order->u.indirect.section->owner;
12998 asection *input_section = link_order->u.indirect.section;
12999 long reloc_size;
13000 arelent **reloc_vector;
13001 long reloc_count;
13002
13003 reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
13004 if (reloc_size < 0)
13005 return NULL;
13006
13007 /* Read in the section. */
13008 if (!nds32_get_section_contents (input_bfd, input_section, &data, FALSE))
13009 return NULL;
13010
13011 if (reloc_size == 0)
13012 return data;
13013
13014 reloc_vector = (arelent **) bfd_malloc (reloc_size);
13015 if (reloc_vector == NULL)
13016 return NULL;
13017
13018 reloc_count = bfd_canonicalize_reloc (input_bfd, input_section,
13019 reloc_vector, symbols);
13020 if (reloc_count < 0)
13021 goto error_return;
13022
13023 if (reloc_count > 0)
13024 {
13025 arelent **parent;
13026 for (parent = reloc_vector; *parent != NULL; parent++)
13027 {
13028 char *error_message = NULL;
13029 asymbol *symbol;
13030 bfd_reloc_status_type r;
13031
13032 symbol = *(*parent)->sym_ptr_ptr;
13033 if (symbol->section && discarded_section (symbol->section))
13034 {
13035 bfd_byte *p;
13036 static reloc_howto_type none_howto
13037 = HOWTO (0, 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL,
13038 "unused", FALSE, 0, 0, FALSE);
13039
13040 p = data + (*parent)->address * bfd_octets_per_byte (input_bfd);
13041 _bfd_clear_contents ((*parent)->howto, input_bfd, input_section,
13042 p);
13043 (*parent)->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
13044 (*parent)->addend = 0;
13045 (*parent)->howto = &none_howto;
13046 r = bfd_reloc_ok;
13047 }
13048 else
13049 r = bfd_perform_relocation (input_bfd, *parent, data,
13050 input_section,
13051 relocatable ? abfd : NULL,
13052 &error_message);
13053
13054 if (relocatable)
13055 {
13056 asection *os = input_section->output_section;
13057
13058 /* A partial link, so keep the relocs. */
13059 os->orelocation[os->reloc_count] = *parent;
13060 os->reloc_count++;
13061 }
13062
13063 if (r != bfd_reloc_ok)
13064 {
13065 switch (r)
13066 {
13067 case bfd_reloc_undefined:
13068 (*link_info->callbacks->undefined_symbol)
13069 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13070 input_bfd, input_section, (*parent)->address, TRUE);
13071 break;
13072 case bfd_reloc_dangerous:
13073 BFD_ASSERT (error_message != NULL);
13074 (*link_info->callbacks->reloc_dangerous)
13075 (link_info, error_message,
13076 input_bfd, input_section, (*parent)->address);
13077 break;
13078 case bfd_reloc_overflow:
13079 (*link_info->callbacks->reloc_overflow)
13080 (link_info, NULL,
13081 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
13082 (*parent)->howto->name, (*parent)->addend,
13083 input_bfd, input_section, (*parent)->address);
13084 break;
13085 case bfd_reloc_outofrange:
13086 /* PR ld/13730:
13087 This error can result when processing some partially
13088 complete binaries. Do not abort, but issue an error
13089 message instead. */
13090 link_info->callbacks->einfo
13091 (_("%X%P: %B(%A): relocation \"%R\" goes out of range\n"),
13092 abfd, input_section, * parent);
13093 goto error_return;
13094
13095 default:
13096 abort ();
13097 break;
13098 }
13099 }
13100 }
13101 }
13102
13103 free (reloc_vector);
13104 return data;
13105
13106 error_return:
13107 free (reloc_vector);
13108 return NULL;
13109 }
13110 \f
13111 /* Link-time IFC relaxation.
13112 In this optimization, we chains jump instructions
13113 of the same destination with ifcall. */
13114
13115
13116 /* List to save jal and j relocation. */
13117 struct elf_nds32_ifc_symbol_entry
13118 {
13119 asection *sec;
13120 struct elf_link_hash_entry *h;
13121 struct elf_nds32_ifc_irel_list *irel_head;
13122 unsigned long insn;
13123 int times;
13124 int enable; /* Apply ifc. */
13125 int ex9_enable; /* Apply ifc after ex9. */
13126 struct elf_nds32_ifc_symbol_entry *next;
13127 };
13128
13129 struct elf_nds32_ifc_irel_list
13130 {
13131 Elf_Internal_Rela *irel;
13132 asection *sec;
13133 bfd_vma addr;
13134 /* If this is set, then it is the last instruction for
13135 ifc-chain, so it must be keep for the actual branching. */
13136 int keep;
13137 struct elf_nds32_ifc_irel_list *next;
13138 };
13139
13140 static struct elf_nds32_ifc_symbol_entry *ifc_symbol_head = NULL;
13141
13142 /* Insert symbol of jal and j for ifc. */
13143
13144 static void
13145 nds32_elf_ifc_insert_symbol (asection *sec,
13146 struct elf_link_hash_entry *h,
13147 Elf_Internal_Rela *irel,
13148 unsigned long insn)
13149 {
13150 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13151
13152 /* Check there is target of existing entry the same as the new one. */
13153 while (ptr != NULL)
13154 {
13155 if (((h == NULL && ptr->sec == sec
13156 && ELF32_R_SYM (ptr->irel_head->irel->r_info) == ELF32_R_SYM (irel->r_info)
13157 && ptr->irel_head->irel->r_addend == irel->r_addend)
13158 || h != NULL)
13159 && ptr->h == h
13160 && ptr->insn == insn)
13161 {
13162 /* The same target exist, so insert into list. */
13163 struct elf_nds32_ifc_irel_list *irel_list = ptr->irel_head;
13164
13165 while (irel_list->next != NULL)
13166 irel_list = irel_list->next;
13167 irel_list->next = bfd_malloc (sizeof (struct elf_nds32_ifc_irel_list));
13168 irel_list = irel_list->next;
13169 irel_list->irel = irel;
13170 irel_list->keep = 1;
13171
13172 if (h == NULL)
13173 irel_list->sec = NULL;
13174 else
13175 irel_list->sec = sec;
13176 irel_list->next = NULL;
13177 return;
13178 }
13179 if (ptr->next == NULL)
13180 break;
13181 ptr = ptr->next;
13182 }
13183
13184 /* There is no same target entry, so build a new one. */
13185 if (ifc_symbol_head == NULL)
13186 {
13187 ifc_symbol_head = bfd_malloc (sizeof (struct elf_nds32_ifc_symbol_entry));
13188 ptr = ifc_symbol_head;
13189 }
13190 else
13191 {
13192 ptr->next = bfd_malloc (sizeof (struct elf_nds32_ifc_symbol_entry));
13193 ptr = ptr->next;
13194 }
13195
13196 ptr->h = h;
13197 ptr->irel_head = bfd_malloc (sizeof (struct elf_nds32_ifc_irel_list));
13198 ptr->irel_head->irel = irel;
13199 ptr->insn = insn;
13200 ptr->irel_head->keep = 1;
13201
13202 if (h == NULL)
13203 {
13204 /* Local symbols. */
13205 ptr->sec = sec;
13206 ptr->irel_head->sec = NULL;
13207 }
13208 else
13209 {
13210 /* Global symbol. */
13211 ptr->sec = NULL;
13212 ptr->irel_head->sec = sec;
13213 }
13214
13215 ptr->irel_head->next = NULL;
13216 ptr->times = 0;
13217 ptr->enable = 0;
13218 ptr->ex9_enable = 0;
13219 ptr->next = NULL;
13220 }
13221
13222 /* Gather all jal and j instructions. */
13223
13224 static bfd_boolean
13225 nds32_elf_ifc_calc (struct bfd_link_info *info,
13226 bfd *abfd, asection *sec)
13227 {
13228 Elf_Internal_Rela *internal_relocs;
13229 Elf_Internal_Rela *irelend;
13230 Elf_Internal_Rela *irel;
13231 Elf_Internal_Shdr *symtab_hdr;
13232 bfd_byte *contents = NULL;
13233 uint32_t insn, insn_with_reg;
13234 unsigned long r_symndx;
13235 struct elf_link_hash_entry *h;
13236 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
13237 struct elf_nds32_link_hash_table *table;
13238 bfd_boolean ifc_loop_aware;
13239
13240 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
13241 TRUE /* keep_memory */);
13242 irelend = internal_relocs + sec->reloc_count;
13243 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
13244
13245 /* Check if the object enable ifc. */
13246 irel = find_relocs_at_address (internal_relocs, internal_relocs, irelend,
13247 R_NDS32_RELAX_ENTRY);
13248
13249 if (irel == NULL
13250 || irel >= irelend
13251 || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
13252 || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
13253 && !(irel->r_addend & R_NDS32_RELAX_ENTRY_IFC_FLAG)))
13254 return TRUE;
13255
13256 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
13257 return FALSE;
13258
13259 table = nds32_elf_hash_table (info);
13260 ifc_loop_aware = table->ifc_loop_aware;
13261 while (irel != NULL && irel < irelend)
13262 {
13263 /* Traverse all relocation and gather all of them to build the list. */
13264
13265 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN)
13266 {
13267 if (ifc_loop_aware == 1
13268 && (irel->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG) != 0)
13269 {
13270 /* Check the region if loop or not. If it is true and
13271 ifc-loop-aware is true, ignore the region till region end. */
13272 while (irel != NULL
13273 && irel < irelend
13274 && (ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_REGION_END
13275 || (irel->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG) != 0))
13276 irel++;
13277 }
13278 }
13279
13280 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA)
13281 {
13282 insn = bfd_getb32 (contents + irel->r_offset);
13283 nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
13284 r_symndx = ELF32_R_SYM (irel->r_info);
13285 if (r_symndx < symtab_hdr->sh_info)
13286 {
13287 /* Local symbol. */
13288 nds32_elf_ifc_insert_symbol (sec, NULL, irel, insn_with_reg);
13289 }
13290 else
13291 {
13292 /* External symbol. */
13293 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
13294 nds32_elf_ifc_insert_symbol (sec, h, irel, insn_with_reg);
13295 }
13296 }
13297 irel++;
13298 }
13299 return TRUE;
13300 }
13301
13302 /* Determine whether j and jal should be substituted. */
13303
13304 static void
13305 nds32_elf_ifc_filter (struct bfd_link_info *info)
13306 {
13307 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13308 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13309 struct elf_nds32_ifc_irel_list *irel_keeper = NULL;
13310 struct elf_nds32_link_hash_table *table;
13311 int target_optimize;
13312 bfd_vma address;
13313
13314 table = nds32_elf_hash_table (info);
13315 target_optimize = table->target_optimize;
13316 while (ptr)
13317 {
13318 irel_ptr = ptr->irel_head;
13319 if (ptr->h == NULL)
13320 {
13321 /* Local symbol. */
13322 irel_keeper = irel_ptr;
13323 while (irel_ptr && irel_ptr->next)
13324 {
13325 /* Check there is jump target can be used. */
13326 if ((irel_ptr->next->irel->r_offset
13327 - irel_keeper->irel->r_offset) > 1022)
13328 irel_keeper = irel_ptr->next;
13329 else
13330 {
13331 ptr->enable = 1;
13332 irel_ptr->keep = 0;
13333 }
13334 irel_ptr = irel_ptr->next;
13335 }
13336 }
13337 else
13338 {
13339 /* Global symbol. */
13340 /* We have to get the absolute address and decide
13341 whether to keep it or not. */
13342 while (irel_ptr)
13343 {
13344 address = (irel_ptr->irel->r_offset
13345 + irel_ptr->sec->output_section->vma
13346 + irel_ptr->sec->output_offset);
13347 irel_ptr->addr = address;
13348 irel_ptr = irel_ptr->next;
13349 }
13350
13351 irel_ptr = ptr->irel_head;
13352 while (irel_ptr)
13353 {
13354 /* Sort by address. */
13355 struct elf_nds32_ifc_irel_list *irel_dest = irel_ptr;
13356 struct elf_nds32_ifc_irel_list *irel_temp = irel_ptr;
13357 struct elf_nds32_ifc_irel_list *irel_ptr_prev = NULL;
13358 struct elf_nds32_ifc_irel_list *irel_dest_prev = NULL;
13359
13360 /* Get the smallest one. */
13361 while (irel_temp->next)
13362 {
13363 if (irel_temp->next->addr < irel_dest->addr)
13364 {
13365 irel_dest_prev = irel_temp;
13366 irel_dest = irel_temp->next;
13367 }
13368 irel_temp = irel_temp->next;
13369 }
13370
13371 if (irel_dest != irel_ptr)
13372 {
13373 if (irel_ptr_prev)
13374 irel_ptr_prev->next = irel_dest;
13375 if (irel_dest_prev)
13376 irel_dest_prev->next = irel_ptr;
13377 irel_temp = irel_ptr->next;
13378 irel_ptr->next = irel_dest->next;
13379 irel_dest->next = irel_temp;
13380 }
13381 irel_ptr_prev = irel_ptr;
13382 irel_ptr = irel_ptr->next;
13383 }
13384
13385 irel_ptr = ptr->irel_head;
13386 irel_keeper = irel_ptr;
13387 while (irel_ptr && irel_ptr->next)
13388 {
13389 if ((irel_ptr->next->addr - irel_keeper->addr) > 1022)
13390 irel_keeper = irel_ptr->next;
13391 else
13392 {
13393 ptr->enable = 1;
13394 irel_ptr->keep = 0;
13395 }
13396 irel_ptr = irel_ptr->next;
13397 }
13398 }
13399
13400 /* Ex9 enable. Reserve it for ex9. */
13401 if ((target_optimize & NDS32_RELAX_EX9_ON)
13402 && ptr->irel_head != irel_keeper)
13403 ptr->enable = 0;
13404 ptr = ptr->next;
13405 }
13406 }
13407
13408 /* Determine whether j and jal should be substituted after ex9 done. */
13409
13410 static void
13411 nds32_elf_ifc_filter_after_ex9 (void)
13412 {
13413 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13414 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13415
13416 while (ptr)
13417 {
13418 if (ptr->enable == 0)
13419 {
13420 /* Check whether ifc is applied or not. */
13421 irel_ptr = ptr->irel_head;
13422 ptr->ex9_enable = 1;
13423 while (irel_ptr)
13424 {
13425 if (ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_TRAN)
13426 {
13427 /* Ex9 already. */
13428 ptr->ex9_enable = 0;
13429 break;
13430 }
13431 irel_ptr = irel_ptr->next;
13432 }
13433 }
13434 ptr = ptr->next;
13435 }
13436 }
13437
13438 /* Wrapper to do ifc relaxation. */
13439
13440 bfd_boolean
13441 nds32_elf_ifc_finish (struct bfd_link_info *info)
13442 {
13443 int relax_status;
13444 struct elf_nds32_link_hash_table *table;
13445
13446 table = nds32_elf_hash_table (info);
13447 relax_status = table->relax_status;
13448
13449 if (!(relax_status & NDS32_RELAX_JUMP_IFC_DONE))
13450 nds32_elf_ifc_filter (info);
13451 else
13452 nds32_elf_ifc_filter_after_ex9 ();
13453
13454 if (!nds32_elf_ifc_replace (info))
13455 return FALSE;
13456
13457 if (table)
13458 table->relax_status |= NDS32_RELAX_JUMP_IFC_DONE;
13459 return TRUE;
13460 }
13461
13462 /* Traverse the result of ifc filter and replace it with ifcall9. */
13463
13464 static bfd_boolean
13465 nds32_elf_ifc_replace (struct bfd_link_info *info)
13466 {
13467 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13468 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13469 nds32_elf_blank_t *relax_blank_list = NULL;
13470 bfd_byte *contents = NULL;
13471 Elf_Internal_Rela *internal_relocs;
13472 Elf_Internal_Rela *irel;
13473 Elf_Internal_Rela *irelend;
13474 unsigned short insn16 = INSN_IFCALL9;
13475 struct elf_nds32_link_hash_table *table;
13476 int relax_status;
13477
13478 table = nds32_elf_hash_table (info);
13479 relax_status = table->relax_status;
13480
13481 while (ptr)
13482 {
13483 /* Traverse the ifc gather list, and replace the
13484 filter entries by ifcall9. */
13485 if ((!(relax_status & NDS32_RELAX_JUMP_IFC_DONE) && ptr->enable == 1)
13486 || ((relax_status & NDS32_RELAX_JUMP_IFC_DONE)
13487 && ptr->ex9_enable == 1))
13488 {
13489 irel_ptr = ptr->irel_head;
13490 if (ptr->h == NULL)
13491 {
13492 /* Local symbol. */
13493 internal_relocs = _bfd_elf_link_read_relocs
13494 (ptr->sec->owner, ptr->sec, NULL, NULL, TRUE /* keep_memory */);
13495 irelend = internal_relocs + ptr->sec->reloc_count;
13496
13497 if (!nds32_get_section_contents (ptr->sec->owner, ptr->sec,
13498 &contents, TRUE))
13499 return FALSE;
13500
13501 while (irel_ptr)
13502 {
13503 if (irel_ptr->keep == 0 && irel_ptr->next)
13504 {
13505 /* The one can be replaced. We have to check whether
13506 there is any alignment point in the region. */
13507 irel = irel_ptr->irel;
13508 while (((irel_ptr->next->keep == 0
13509 && irel < irel_ptr->next->irel)
13510 || (irel_ptr->next->keep == 1 && irel < irelend))
13511 && !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13512 && (irel->r_addend & 0x1f) == 2))
13513 irel++;
13514 if (irel >= irelend
13515 || !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13516 && (irel->r_addend & 0x1f) == 2
13517 && ((irel->r_offset - get_nds32_elf_blank_total
13518 (&relax_blank_list, irel->r_offset, 1))
13519 & 0x02) == 0))
13520 {
13521 /* Replace by ifcall9. */
13522 bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13523 if (!insert_nds32_elf_blank_recalc_total
13524 (&relax_blank_list, irel_ptr->irel->r_offset + 2, 2))
13525 return FALSE;
13526 irel_ptr->irel->r_info =
13527 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13528 R_NDS32_10IFCU_PCREL_RELA);
13529 }
13530 }
13531 irel_ptr = irel_ptr->next;
13532 }
13533
13534 /* Delete the redundant code. */
13535 if (relax_blank_list)
13536 {
13537 nds32_elf_relax_delete_blanks (ptr->sec->owner, ptr->sec,
13538 relax_blank_list);
13539 relax_blank_list = NULL;
13540 }
13541 }
13542 else
13543 {
13544 /* Global symbol. */
13545 while (irel_ptr)
13546 {
13547 if (irel_ptr->keep == 0 && irel_ptr->next)
13548 {
13549 /* The one can be replaced, and we have to check
13550 whether there is any alignment point in the region. */
13551 internal_relocs = _bfd_elf_link_read_relocs
13552 (irel_ptr->sec->owner, irel_ptr->sec, NULL, NULL,
13553 TRUE /* keep_memory */);
13554 irelend = internal_relocs + irel_ptr->sec->reloc_count;
13555 if (!nds32_get_section_contents (irel_ptr->sec->owner,
13556 irel_ptr->sec, &contents,
13557 TRUE))
13558 return FALSE;
13559
13560 irel = irel_ptr->irel;
13561 while (((irel_ptr->sec == irel_ptr->next->sec
13562 && irel_ptr->next->keep == 0
13563 && irel < irel_ptr->next->irel)
13564 || ((irel_ptr->sec != irel_ptr->next->sec
13565 || irel_ptr->next->keep == 1)
13566 && irel < irelend))
13567 && !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13568 && (irel->r_addend & 0x1f) == 2))
13569 irel++;
13570 if (irel >= irelend
13571 || !(ELF32_R_TYPE (irel->r_info) == R_NDS32_LABEL
13572 && (irel->r_addend & 0x1f) == 2
13573 && ((irel->r_offset
13574 - get_nds32_elf_blank_total (&relax_blank_list,
13575 irel->r_offset, 1)) & 0x02) == 0))
13576 {
13577 /* Replace by ifcall9. */
13578 bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13579 if (!insert_nds32_elf_blank_recalc_total
13580 (&relax_blank_list, irel_ptr->irel->r_offset + 2, 2))
13581 return FALSE;
13582
13583 /* Delete the redundant code, and clear the relocation. */
13584 nds32_elf_relax_delete_blanks (irel_ptr->sec->owner,
13585 irel_ptr->sec,
13586 relax_blank_list);
13587 irel_ptr->irel->r_info =
13588 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13589 R_NDS32_10IFCU_PCREL_RELA);
13590 relax_blank_list = NULL;
13591 }
13592 }
13593
13594 irel_ptr = irel_ptr->next;
13595 }
13596 }
13597 }
13598 ptr = ptr->next;
13599 }
13600
13601 return TRUE;
13602 }
13603
13604 /* Relocate ifcall. */
13605
13606 static bfd_boolean
13607 nds32_elf_ifc_reloc (void)
13608 {
13609 struct elf_nds32_ifc_symbol_entry *ptr = ifc_symbol_head;
13610 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
13611 struct elf_nds32_ifc_irel_list *irel_keeper = NULL;
13612 bfd_vma relocation, address;
13613 unsigned short insn16;
13614 bfd_byte *contents = NULL;
13615 static bfd_boolean done = FALSE;
13616
13617 if (done)
13618 return TRUE;
13619
13620 done = TRUE;
13621
13622 while (ptr)
13623 {
13624 /* Check the entry is enable ifcall. */
13625 if (ptr->enable == 1 || ptr->ex9_enable == 1)
13626 {
13627 /* Get the reserve jump. */
13628 irel_ptr = ptr->irel_head;
13629 while (irel_ptr)
13630 {
13631 if (irel_ptr->keep == 1)
13632 {
13633 irel_keeper = irel_ptr;
13634 break;
13635 }
13636 irel_ptr = irel_ptr->next;
13637 }
13638
13639 irel_ptr = ptr->irel_head;
13640 if (ptr->h == NULL)
13641 {
13642 /* Local symbol. */
13643 if (!nds32_get_section_contents (ptr->sec->owner, ptr->sec,
13644 &contents, TRUE))
13645 return FALSE;
13646
13647 while (irel_ptr)
13648 {
13649 if (irel_ptr->keep == 0
13650 && ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
13651 {
13652 relocation = irel_keeper->irel->r_offset;
13653 relocation = relocation - irel_ptr->irel->r_offset;
13654 while (irel_keeper && relocation > 1022)
13655 {
13656 irel_keeper = irel_keeper->next;
13657 if (irel_keeper && irel_keeper->keep == 1)
13658 {
13659 relocation = irel_keeper->irel->r_offset;
13660 relocation = relocation - irel_ptr->irel->r_offset;
13661 }
13662 }
13663 if (relocation > 1022)
13664 {
13665 /* Double check. */
13666 irel_keeper = ptr->irel_head;
13667 while (irel_keeper)
13668 {
13669 if (irel_keeper->keep == 1)
13670 {
13671 relocation = irel_keeper->irel->r_offset;
13672 relocation = relocation - irel_ptr->irel->r_offset;
13673 }
13674 if (relocation <= 1022)
13675 break;
13676 irel_keeper = irel_keeper->next;
13677 }
13678 if (!irel_keeper)
13679 return FALSE;
13680 }
13681 irel_ptr->irel->r_info =
13682 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13683 R_NDS32_NONE);
13684 insn16 = INSN_IFCALL9 | (relocation >> 1);
13685 bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13686 }
13687 irel_ptr = irel_ptr->next;
13688 }
13689 }
13690 else
13691 {
13692 /* Global symbol. */
13693 while (irel_ptr)
13694 {
13695 if (irel_ptr->keep == 0
13696 && ELF32_R_TYPE (irel_ptr->irel->r_info) == R_NDS32_10IFCU_PCREL_RELA)
13697 {
13698 /* Get the distance between ifcall and jump. */
13699 relocation = (irel_keeper->irel->r_offset
13700 + irel_keeper->sec->output_section->vma
13701 + irel_keeper->sec->output_offset);
13702 address = (irel_ptr->irel->r_offset
13703 + irel_ptr->sec->output_section->vma
13704 + irel_ptr->sec->output_offset);
13705 relocation = relocation - address;
13706
13707 /* The distance is over ragne, find callee again. */
13708 while (irel_keeper && relocation > 1022)
13709 {
13710 irel_keeper = irel_keeper->next;
13711 if (irel_keeper && irel_keeper->keep ==1)
13712 {
13713 relocation = (irel_keeper->irel->r_offset
13714 + irel_keeper->sec->output_section->vma
13715 + irel_keeper->sec->output_offset);
13716 relocation = relocation - address;
13717 }
13718 }
13719
13720 if (relocation > 1022)
13721 {
13722 /* Double check. */
13723 irel_keeper = ptr->irel_head;
13724 while (irel_keeper)
13725 {
13726 if (irel_keeper->keep == 1)
13727 {
13728
13729 relocation = (irel_keeper->irel->r_offset
13730 + irel_keeper->sec->output_section->vma
13731 + irel_keeper->sec->output_offset);
13732 relocation = relocation - address;
13733 }
13734 if (relocation <= 1022)
13735 break;
13736 irel_keeper = irel_keeper->next;
13737 }
13738 if (!irel_keeper)
13739 return FALSE;
13740 }
13741 if (!nds32_get_section_contents
13742 (irel_ptr->sec->owner, irel_ptr->sec, &contents, TRUE))
13743 return FALSE;
13744 insn16 = INSN_IFCALL9 | (relocation >> 1);
13745 bfd_putb16 (insn16, contents + irel_ptr->irel->r_offset);
13746 irel_ptr->irel->r_info =
13747 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info),
13748 R_NDS32_NONE);
13749 }
13750 irel_ptr =irel_ptr->next;
13751 }
13752 }
13753 }
13754 ptr = ptr->next;
13755 }
13756
13757 return TRUE;
13758 }
13759
13760 /* End of IFC relaxation. */
13761 \f
13762 /* EX9 Instruction Table Relaxation. */
13763
13764 /* Global hash list. */
13765 struct elf_link_hash_entry_list
13766 {
13767 struct elf_link_hash_entry *h;
13768 struct elf_link_hash_entry_list *next;
13769 };
13770
13771 /* Save different destination but same insn. */
13772 struct elf_link_hash_entry_mul_list
13773 {
13774 /* Global symbol times. */
13775 int times;
13776 /* Save relocation for each global symbol but useful?? */
13777 Elf_Internal_Rela *irel;
13778 /* For sethi, two sethi may have the same high-part but different low-parts. */
13779 Elf_Internal_Rela rel_backup;
13780 struct elf_link_hash_entry_list *h_list;
13781 struct elf_link_hash_entry_mul_list *next;
13782 };
13783
13784 /* Instruction hash table. */
13785 struct elf_nds32_code_hash_entry
13786 {
13787 struct bfd_hash_entry root;
13788 int times;
13789 /* For insn that can use relocation or constant ex: sethi. */
13790 int const_insn;
13791 asection *sec;
13792 struct elf_link_hash_entry_mul_list *m_list;
13793 /* Using r_addend. */
13794 Elf_Internal_Rela *irel;
13795 /* Using r_info. */
13796 Elf_Internal_Rela rel_backup;
13797 };
13798
13799 /* Instruction count list. */
13800 struct elf_nds32_insn_times_entry
13801 {
13802 const char *string;
13803 int times;
13804 int order;
13805 asection *sec;
13806 struct elf_link_hash_entry_mul_list *m_list;
13807 Elf_Internal_Rela *irel;
13808 Elf_Internal_Rela rel_backup;
13809 struct elf_nds32_insn_times_entry *next;
13810 };
13811
13812 /* J and JAL symbol list. */
13813 struct elf_nds32_symbol_entry
13814 {
13815 char *string;
13816 unsigned long insn;
13817 struct elf_nds32_symbol_entry *next;
13818 };
13819
13820 /* Relocation list. */
13821 struct elf_nds32_irel_entry
13822 {
13823 Elf_Internal_Rela *irel;
13824 struct elf_nds32_irel_entry *next;
13825 };
13826
13827 /* ex9.it insn need to be fixed. */
13828 struct elf_nds32_ex9_refix
13829 {
13830 Elf_Internal_Rela *irel;
13831 asection *sec;
13832 struct elf_link_hash_entry *h;
13833 int order;
13834 struct elf_nds32_ex9_refix *next;
13835 };
13836
13837 static struct bfd_hash_table ex9_code_table;
13838 static struct elf_nds32_insn_times_entry *ex9_insn_head = NULL;
13839 static struct elf_nds32_ex9_refix *ex9_refix_head = NULL;
13840
13841 /* EX9 hash function. */
13842
13843 static struct bfd_hash_entry *
13844 nds32_elf_code_hash_newfunc (struct bfd_hash_entry *entry,
13845 struct bfd_hash_table *table,
13846 const char *string)
13847 {
13848 struct elf_nds32_code_hash_entry *ret;
13849
13850 /* Allocate the structure if it has not already been allocated by a
13851 subclass. */
13852 if (entry == NULL)
13853 {
13854 entry = (struct bfd_hash_entry *)
13855 bfd_hash_allocate (table, sizeof (*ret));
13856 if (entry == NULL)
13857 return entry;
13858 }
13859
13860 /* Call the allocation method of the superclass. */
13861 entry = bfd_hash_newfunc (entry, table, string);
13862 if (entry == NULL)
13863 return entry;
13864
13865 ret = (struct elf_nds32_code_hash_entry*) entry;
13866 ret->times = 0;
13867 ret->const_insn = 0;
13868 ret->m_list = NULL;
13869 ret->sec = NULL;
13870 ret->irel = NULL;
13871 return &ret->root;
13872 }
13873
13874 /* Insert ex9 entry
13875 this insert must be stable sorted by times. */
13876
13877 static void
13878 nds32_elf_ex9_insert_entry (struct elf_nds32_insn_times_entry *ptr)
13879 {
13880 struct elf_nds32_insn_times_entry *temp;
13881 struct elf_nds32_insn_times_entry *temp2;
13882
13883 if (ex9_insn_head == NULL)
13884 {
13885 ex9_insn_head = ptr;
13886 ptr->next = NULL;
13887 }
13888 else
13889 {
13890 temp = ex9_insn_head;
13891 temp2 = ex9_insn_head;
13892 while (temp->next &&
13893 (temp->next->times >= ptr->times
13894 || temp->times == -1))
13895 {
13896 if (temp->times == -1)
13897 temp2 = temp;
13898 temp = temp->next;
13899 }
13900 if (ptr->times > temp->times && temp->times != -1)
13901 {
13902 ptr->next = temp;
13903 if (temp2->times == -1)
13904 temp2->next = ptr;
13905 else
13906 ex9_insn_head = ptr;
13907 }
13908 else if (temp->next == NULL)
13909 {
13910 temp->next = ptr;
13911 ptr->next = NULL;
13912 }
13913 else
13914 {
13915 ptr->next = temp->next;
13916 temp->next = ptr;
13917 }
13918 }
13919 }
13920
13921 /* Examine each insn times in hash table.
13922 Handle multi-link hash entry.
13923
13924 TODO: This function doesn't assign so much info since it is fake. */
13925
13926 static int
13927 nds32_elf_examine_insn_times (struct elf_nds32_code_hash_entry *h)
13928 {
13929 struct elf_nds32_insn_times_entry *ptr;
13930 int times;
13931
13932 if (h->m_list == NULL)
13933 {
13934 /* Local symbol insn or insn without relocation. */
13935 if (h->times < 3)
13936 return TRUE;
13937
13938 ptr = (struct elf_nds32_insn_times_entry *)
13939 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13940 ptr->times = h->times;
13941 ptr->string = h->root.string;
13942 ptr->m_list = NULL;
13943 ptr->sec = h->sec;
13944 ptr->irel = h->irel;
13945 ptr->rel_backup = h->rel_backup;
13946 nds32_elf_ex9_insert_entry (ptr);
13947 }
13948 else
13949 {
13950 /* Global symbol insn. */
13951 /* Only sethi insn has multiple m_list. */
13952 struct elf_link_hash_entry_mul_list *m_list = h->m_list;
13953
13954 times = 0;
13955 while (m_list)
13956 {
13957 times += m_list->times;
13958 m_list = m_list->next;
13959 }
13960 if (times >= 3)
13961 {
13962 m_list = h->m_list;
13963 ptr = (struct elf_nds32_insn_times_entry *)
13964 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13965 ptr->times = times; /* Use the total times. */
13966 ptr->string = h->root.string;
13967 ptr->m_list = m_list;
13968 ptr->sec = h->sec;
13969 ptr->irel = m_list->irel;
13970 ptr->rel_backup = m_list->rel_backup;
13971 nds32_elf_ex9_insert_entry (ptr);
13972 }
13973 if (h->const_insn == 1)
13974 {
13975 /* sethi with constant value. */
13976 if (h->times < 3)
13977 return TRUE;
13978
13979 ptr = (struct elf_nds32_insn_times_entry *)
13980 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
13981 ptr->times = h->times;
13982 ptr->string = h->root.string;
13983 ptr->m_list = NULL;
13984 ptr->sec = NULL;
13985 ptr->irel = NULL;
13986 ptr->rel_backup = h->rel_backup;
13987 nds32_elf_ex9_insert_entry (ptr);
13988 }
13989 }
13990 return TRUE;
13991 }
13992
13993 /* Count each insn times in hash table.
13994 Handle multi-link hash entry. */
13995
13996 static int
13997 nds32_elf_count_insn_times (struct elf_nds32_code_hash_entry *h)
13998 {
13999 int reservation, times;
14000 unsigned long relocation, min_relocation;
14001 struct elf_nds32_insn_times_entry *ptr;
14002
14003 if (h->m_list == NULL)
14004 {
14005 /* Local symbol insn or insn without relocation. */
14006 if (h->times < 3)
14007 return TRUE;
14008 ptr = (struct elf_nds32_insn_times_entry *)
14009 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14010 ptr->times = h->times;
14011 ptr->string = h->root.string;
14012 ptr->m_list = NULL;
14013 ptr->sec = h->sec;
14014 ptr->irel = h->irel;
14015 ptr->rel_backup = h->rel_backup;
14016 nds32_elf_ex9_insert_entry (ptr);
14017 }
14018 else
14019 {
14020 /* Global symbol insn. */
14021 /* Only sethi insn has multiple m_list. */
14022 struct elf_link_hash_entry_mul_list *m_list = h->m_list;
14023
14024 if (ELF32_R_TYPE (m_list->rel_backup.r_info) == R_NDS32_HI20_RELA
14025 && m_list->next != NULL)
14026 {
14027 /* Sethi insn has different symbol or addend but has same hi20. */
14028 times = 0;
14029 reservation = 1;
14030 relocation = 0;
14031 min_relocation = 0xffffffff;
14032 while (m_list)
14033 {
14034 /* Get the minimum sethi address
14035 and calculate how many entry the sethi-list have to use. */
14036 if ((m_list->h_list->h->root.type == bfd_link_hash_defined
14037 || m_list->h_list->h->root.type == bfd_link_hash_defweak)
14038 && (m_list->h_list->h->root.u.def.section != NULL
14039 && m_list->h_list->h->root.u.def.section->output_section != NULL))
14040 {
14041 relocation = (m_list->h_list->h->root.u.def.value +
14042 m_list->h_list->h->root.u.def.section->output_section->vma +
14043 m_list->h_list->h->root.u.def.section->output_offset);
14044 relocation += m_list->irel->r_addend;
14045 }
14046 else
14047 relocation = 0;
14048 if (relocation < min_relocation)
14049 min_relocation = relocation;
14050 times += m_list->times;
14051 m_list = m_list->next;
14052 }
14053 if (min_relocation < ex9_relax_size)
14054 reservation = (min_relocation >> 12) + 1;
14055 else
14056 reservation = (min_relocation >> 12)
14057 - ((min_relocation - ex9_relax_size) >> 12) + 1;
14058 if (reservation < (times / 3))
14059 {
14060 /* Efficient enough to use ex9. */
14061 int i;
14062
14063 for (i = reservation ; i > 0; i--)
14064 {
14065 /* Allocate number of reservation ex9 entry. */
14066 ptr = (struct elf_nds32_insn_times_entry *)
14067 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14068 ptr->times = h->m_list->times / reservation;
14069 ptr->string = h->root.string;
14070 ptr->m_list = h->m_list;
14071 ptr->sec = h->sec;
14072 ptr->irel = h->m_list->irel;
14073 ptr->rel_backup = h->m_list->rel_backup;
14074 nds32_elf_ex9_insert_entry (ptr);
14075 }
14076 }
14077 }
14078 else
14079 {
14080 /* Normal global symbol that means no different address symbol
14081 using same ex9 entry. */
14082 if (m_list->times >= 3)
14083 {
14084 ptr = (struct elf_nds32_insn_times_entry *)
14085 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14086 ptr->times = m_list->times;
14087 ptr->string = h->root.string;
14088 ptr->m_list = h->m_list;
14089 ptr->sec = h->sec;
14090 ptr->irel = h->m_list->irel;
14091 ptr->rel_backup = h->m_list->rel_backup;
14092 nds32_elf_ex9_insert_entry (ptr);
14093 }
14094 }
14095
14096 if (h->const_insn == 1)
14097 {
14098 /* sethi with constant value. */
14099 if (h->times < 3)
14100 return TRUE;
14101
14102 ptr = (struct elf_nds32_insn_times_entry *)
14103 bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
14104 ptr->times = h->times;
14105 ptr->string = h->root.string;
14106 ptr->m_list = NULL;
14107 ptr->sec = NULL;
14108 ptr->irel = NULL;
14109 ptr->rel_backup = h->rel_backup;
14110 nds32_elf_ex9_insert_entry (ptr);
14111 }
14112 }
14113
14114 return TRUE;
14115 }
14116
14117 /* Hash table traverse function. */
14118
14119 static void
14120 nds32_elf_code_hash_traverse (int (*func) (struct elf_nds32_code_hash_entry*))
14121 {
14122 unsigned int i;
14123
14124 ex9_code_table.frozen = 1;
14125 for (i = 0; i < ex9_code_table.size; i++)
14126 {
14127 struct bfd_hash_entry *p;
14128
14129 for (p = ex9_code_table.table[i]; p != NULL; p = p->next)
14130 if (!func ((struct elf_nds32_code_hash_entry *) p))
14131 goto out;
14132 }
14133 out:
14134 ex9_code_table.frozen = 0;
14135 }
14136
14137
14138 /* Give order number to insn list. */
14139
14140 static void
14141 nds32_elf_order_insn_times (struct bfd_link_info *info)
14142 {
14143 struct elf_nds32_insn_times_entry *ex9_insn;
14144 struct elf_nds32_insn_times_entry *temp = NULL;
14145 struct elf_nds32_link_hash_table *table;
14146 int ex9_limit;
14147 int number = 0;
14148
14149 if (ex9_insn_head == NULL)
14150 return;
14151
14152 /* The max number of entries is 512. */
14153 ex9_insn = ex9_insn_head;
14154 table = nds32_elf_hash_table (info);
14155 ex9_limit = table->ex9_limit;
14156
14157 ex9_insn = ex9_insn_head;
14158
14159 while (ex9_insn != NULL && number < ex9_limit)
14160 {
14161 ex9_insn->order = number;
14162 number++;
14163 temp = ex9_insn;
14164 ex9_insn = ex9_insn->next;
14165 }
14166
14167 if (ex9_insn && temp)
14168 temp->next = NULL;
14169
14170 while (ex9_insn != NULL)
14171 {
14172 /* Free useless entry. */
14173 temp = ex9_insn;
14174 ex9_insn = ex9_insn->next;
14175 free (temp);
14176 }
14177 }
14178
14179 /* Build .ex9.itable section. */
14180
14181 static void
14182 nds32_elf_ex9_build_itable (struct bfd_link_info *link_info)
14183 {
14184 asection *table_sec;
14185 struct elf_nds32_insn_times_entry *ptr;
14186 bfd *it_abfd;
14187 int number = 0;
14188 bfd_byte *contents = NULL;
14189
14190 for (it_abfd = link_info->input_bfds; it_abfd != NULL;
14191 it_abfd = it_abfd->link.next)
14192 {
14193 /* Find the section .ex9.itable, and put all entries into it. */
14194 table_sec = bfd_get_section_by_name (it_abfd, ".ex9.itable");
14195 if (table_sec != NULL)
14196 {
14197 if (!nds32_get_section_contents (it_abfd, table_sec, &contents, TRUE))
14198 return;
14199
14200 for (ptr = ex9_insn_head; ptr !=NULL ; ptr = ptr->next)
14201 number++;
14202
14203 table_sec->size = number * 4;
14204
14205 if (number == 0)
14206 return;
14207
14208 elf_elfheader (link_info->output_bfd)->e_flags |= E_NDS32_HAS_EX9_INST;
14209 number = 0;
14210 for (ptr = ex9_insn_head; ptr !=NULL ; ptr = ptr->next)
14211 {
14212 long val;
14213
14214 val = strtol (ptr->string, NULL, 16);
14215 bfd_putb32 ((bfd_vma) val, (char *) contents + (number * 4));
14216 number++;
14217 }
14218 break;
14219 }
14220 }
14221 }
14222
14223 /* Get insn with regs according to relocation type. */
14224
14225 static void
14226 nds32_elf_get_insn_with_reg (Elf_Internal_Rela *irel,
14227 uint32_t insn, uint32_t *insn_with_reg)
14228 {
14229 reloc_howto_type *howto = NULL;
14230
14231 if (irel == NULL
14232 || (ELF32_R_TYPE (irel->r_info) >= (int) ARRAY_SIZE (nds32_elf_howto_table)
14233 && (ELF32_R_TYPE (irel->r_info) - R_NDS32_RELAX_ENTRY)
14234 >= (int) ARRAY_SIZE (nds32_elf_relax_howto_table)))
14235 {
14236 *insn_with_reg = insn;
14237 return;
14238 }
14239
14240 howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
14241 *insn_with_reg = insn & (0xffffffff ^ howto->dst_mask);
14242 }
14243
14244 /* Mask number of address bits according to relocation. */
14245
14246 static unsigned long
14247 nds32_elf_irel_mask (Elf_Internal_Rela *irel)
14248 {
14249 reloc_howto_type *howto = NULL;
14250
14251 if (irel == NULL
14252 || (ELF32_R_TYPE (irel->r_info) >= (int) ARRAY_SIZE (nds32_elf_howto_table)
14253 && (ELF32_R_TYPE (irel->r_info) - R_NDS32_RELAX_ENTRY)
14254 >= (int) ARRAY_SIZE (nds32_elf_relax_howto_table)))
14255 return 0;
14256
14257 howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
14258 return howto->dst_mask;
14259 }
14260
14261 static void
14262 nds32_elf_insert_irel_entry (struct elf_nds32_irel_entry **irel_list,
14263 struct elf_nds32_irel_entry *irel_ptr)
14264 {
14265 if (*irel_list == NULL)
14266 {
14267 *irel_list = irel_ptr;
14268 irel_ptr->next = NULL;
14269 }
14270 else
14271 {
14272 irel_ptr->next = *irel_list;
14273 *irel_list = irel_ptr;
14274 }
14275 }
14276
14277 static void
14278 nds32_elf_ex9_insert_fix (asection * sec, Elf_Internal_Rela * irel,
14279 struct elf_link_hash_entry *h, int order)
14280 {
14281 struct elf_nds32_ex9_refix *ptr;
14282
14283 ptr = bfd_malloc (sizeof (struct elf_nds32_ex9_refix));
14284 ptr->sec = sec;
14285 ptr->irel = irel;
14286 ptr->h = h;
14287 ptr->order = order;
14288 ptr->next = NULL;
14289
14290 if (ex9_refix_head == NULL)
14291 ex9_refix_head = ptr;
14292 else
14293 {
14294 struct elf_nds32_ex9_refix *temp = ex9_refix_head;
14295
14296 while (temp->next != NULL)
14297 temp = temp->next;
14298 temp->next = ptr;
14299 }
14300 }
14301
14302 enum
14303 {
14304 DATA_EXIST = 1,
14305 CLEAN_PRE = 1 << 1,
14306 PUSH_PRE = 1 << 2
14307 };
14308
14309 /* Check relocation type if supporting for ex9. */
14310
14311 static int
14312 nds32_elf_ex9_relocation_check (struct bfd_link_info *info,
14313 Elf_Internal_Rela **irel,
14314 Elf_Internal_Rela *irelend,
14315 nds32_elf_blank_t *relax_blank_list,
14316 asection *sec,bfd_vma *off,
14317 bfd_byte *contents)
14318 {
14319 /* Suppress ex9 if `.no_relax ex9' or inner loop. */
14320 bfd_boolean nested_ex9, nested_loop;
14321 bfd_boolean ex9_loop_aware;
14322 /* We use the highest 1 byte of result to record
14323 how many bytes location counter has to move. */
14324 int result = 0;
14325 Elf_Internal_Rela *irel_save = NULL;
14326 struct elf_nds32_link_hash_table *table;
14327
14328 table = nds32_elf_hash_table (info);
14329 ex9_loop_aware = table->ex9_loop_aware;
14330
14331 while ((*irel) != NULL && (*irel) < irelend && *off == (*irel)->r_offset)
14332 {
14333 switch (ELF32_R_TYPE ((*irel)->r_info))
14334 {
14335 case R_NDS32_RELAX_REGION_BEGIN:
14336 /* Ignore code block. */
14337 nested_ex9 = FALSE;
14338 nested_loop = FALSE;
14339 if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG)
14340 || (ex9_loop_aware
14341 && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG)))
14342 {
14343 /* Check the region if loop or not. If it is true and
14344 ex9-loop-aware is true, ignore the region till region end. */
14345 /* To save the status for in .no_relax ex9 region and
14346 loop region to conform the block can do ex9 relaxation. */
14347 nested_ex9 = ((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG);
14348 nested_loop = (ex9_loop_aware
14349 && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG));
14350 while ((*irel) && (*irel) < irelend && (nested_ex9 || nested_loop))
14351 {
14352 (*irel)++;
14353 if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_RELAX_REGION_BEGIN)
14354 {
14355 /* There may be nested region. */
14356 if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG) != 0)
14357 nested_ex9 = TRUE;
14358 else if (ex9_loop_aware
14359 && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG))
14360 nested_loop = TRUE;
14361 }
14362 else if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_RELAX_REGION_END)
14363 {
14364 /* The end of region. */
14365 if (((*irel)->r_addend & R_NDS32_RELAX_REGION_NO_EX9_FLAG) != 0)
14366 nested_ex9 = FALSE;
14367 else if (ex9_loop_aware
14368 && ((*irel)->r_addend & R_NDS32_RELAX_REGION_INNERMOST_LOOP_FLAG))
14369 nested_loop = FALSE;
14370 }
14371 else if (ELF32_R_TYPE ((*irel)->r_info) == R_NDS32_LABEL
14372 && ((*irel)->r_addend & 0x1f) == 2)
14373 {
14374 /* Alignment exist in the region. */
14375 result |= CLEAN_PRE;
14376 if (((*irel)->r_offset -
14377 get_nds32_elf_blank_total (&relax_blank_list,
14378 (*irel)->r_offset, 0)) & 0x02)
14379 result |= PUSH_PRE;
14380 }
14381 }
14382 if ((*irel) >= irelend)
14383 *off = sec->size;
14384 else
14385 *off = (*irel)->r_offset;
14386
14387 /* The final instruction in the region, regard this one as data to ignore it. */
14388 result |= DATA_EXIST;
14389 return result;
14390 }
14391 break;
14392
14393 case R_NDS32_LABEL:
14394 if (((*irel)->r_addend & 0x1f) == 2)
14395 {
14396 /* Check this point is align and decide to do ex9 or not. */
14397 result |= CLEAN_PRE;
14398 if (((*irel)->r_offset -
14399 get_nds32_elf_blank_total (&relax_blank_list,
14400 (*irel)->r_offset, 0)) & 0x02)
14401 result |= PUSH_PRE;
14402 }
14403 break;
14404 case R_NDS32_32_RELA:
14405 /* Data. */
14406 result |= (4 << 24);
14407 result |= DATA_EXIST;
14408 break;
14409 case R_NDS32_16_RELA:
14410 /* Data. */
14411 result |= (2 << 24);
14412 result |= DATA_EXIST;
14413 break;
14414 case R_NDS32_DATA:
14415 /* Data. */
14416 /* The least code alignment is 2. If the data is only one byte,
14417 we have to shift one more byte. */
14418 if ((*irel)->r_addend == 1)
14419 result |= ((*irel)->r_addend << 25) ;
14420 else
14421 result |= ((*irel)->r_addend << 24) ;
14422
14423 result |= DATA_EXIST;
14424 break;
14425
14426 case R_NDS32_25_PCREL_RELA:
14427 case R_NDS32_SDA16S3_RELA:
14428 case R_NDS32_SDA15S3_RELA:
14429 case R_NDS32_SDA15S3:
14430 case R_NDS32_SDA17S2_RELA:
14431 case R_NDS32_SDA15S2_RELA:
14432 case R_NDS32_SDA12S2_SP_RELA:
14433 case R_NDS32_SDA12S2_DP_RELA:
14434 case R_NDS32_SDA15S2:
14435 case R_NDS32_SDA18S1_RELA:
14436 case R_NDS32_SDA15S1_RELA:
14437 case R_NDS32_SDA15S1:
14438 case R_NDS32_SDA19S0_RELA:
14439 case R_NDS32_SDA15S0_RELA:
14440 case R_NDS32_SDA15S0:
14441 case R_NDS32_HI20_RELA:
14442 case R_NDS32_LO12S0_ORI_RELA:
14443 case R_NDS32_LO12S0_RELA:
14444 case R_NDS32_LO12S1_RELA:
14445 case R_NDS32_LO12S2_RELA:
14446 /* These relocation is supported ex9 relaxation currently. */
14447 /* We have to save the relocation for using later, since we have
14448 to check there is any alignment in the same address. */
14449 irel_save = *irel;
14450 break;
14451 default:
14452 /* Not support relocations. */
14453 if (ELF32_R_TYPE ((*irel)->r_info) < ARRAY_SIZE (nds32_elf_howto_table)
14454 && ELF32_R_TYPE ((*irel)->r_info) != R_NDS32_NONE
14455 && ELF32_R_TYPE ((*irel)->r_info) != R_NDS32_INSN16)
14456 {
14457 /* Note: To optimize aggressively, it maybe can ignore R_NDS32_INSN16 here.
14458 But we have to consider if there is any side-effect. */
14459 if (!(result & DATA_EXIST))
14460 {
14461 /* We have to confirm there is no data relocation in the
14462 same address. In general case, this won't happen. */
14463 /* We have to do ex9 conservative, for those relocation not
14464 considerd we ignore instruction. */
14465 result |= DATA_EXIST;
14466 if (*(contents + *off) & 0x80)
14467 result |= (2 << 24);
14468 else
14469 result |= (4 << 24);
14470 break;
14471 }
14472 }
14473 }
14474 if ((*irel) < irelend
14475 && ((*irel) + 1) < irelend
14476 && (*irel)->r_offset == ((*irel) + 1)->r_offset)
14477 /* There are relocations pointing to the same address, we have to
14478 check all of them. */
14479 (*irel)++;
14480 else
14481 {
14482 if (irel_save)
14483 *irel = irel_save;
14484 return result;
14485 }
14486 }
14487 return result;
14488 }
14489
14490 /* Replace with ex9 instruction. */
14491
14492 static bfd_boolean
14493 nds32_elf_ex9_push_insn (uint16_t insn16, bfd_byte *contents, bfd_vma pre_off,
14494 nds32_elf_blank_t **relax_blank_list,
14495 struct elf_nds32_irel_entry *pre_irel_ptr,
14496 struct elf_nds32_irel_entry **irel_list)
14497 {
14498 if (insn16 != 0)
14499 {
14500 /* Implement the ex9 relaxation. */
14501 bfd_putb16 (insn16, contents + pre_off);
14502 if (!insert_nds32_elf_blank_recalc_total (relax_blank_list,
14503 pre_off + 2, 2))
14504 return FALSE;
14505 if (pre_irel_ptr != NULL)
14506 nds32_elf_insert_irel_entry (irel_list, pre_irel_ptr);
14507 }
14508 return TRUE;
14509 }
14510
14511 /* Replace input file instruction which is in ex9 itable. */
14512
14513 static bfd_boolean
14514 nds32_elf_ex9_replace_instruction (struct bfd_link_info *info, bfd *abfd, asection *sec)
14515 {
14516 struct elf_nds32_insn_times_entry *ex9_insn = ex9_insn_head;
14517 bfd_byte *contents = NULL;
14518 bfd_vma off;
14519 uint16_t insn16, insn_ex9;
14520 /* `pre_*' are used to track previous instruction that can use ex9.it. */
14521 bfd_vma pre_off = -1;
14522 uint16_t pre_insn16 = 0;
14523 struct elf_nds32_irel_entry *pre_irel_ptr = NULL;
14524 Elf_Internal_Rela *internal_relocs;
14525 Elf_Internal_Rela *irel;
14526 Elf_Internal_Rela *irelend;
14527 Elf_Internal_Shdr *symtab_hdr;
14528 Elf_Internal_Sym *isym = NULL;
14529 nds32_elf_blank_t *relax_blank_list = NULL;
14530 uint32_t insn = 0;
14531 uint32_t insn_with_reg = 0;
14532 uint32_t it_insn;
14533 uint32_t it_insn_with_reg;
14534 unsigned long r_symndx;
14535 asection *isec;
14536 struct elf_nds32_irel_entry *irel_list = NULL;
14537 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
14538 int data_flag, do_replace, save_irel;
14539 struct elf_link_hash_entry_list *h_list;
14540
14541
14542 /* Load section instructions, relocations, and symbol table. */
14543 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE)
14544 || !nds32_get_local_syms (abfd, sec, &isym))
14545 return FALSE;
14546 internal_relocs =
14547 _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, TRUE /* keep_memory */);
14548 irelend = internal_relocs + sec->reloc_count;
14549 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
14550
14551 off = 0;
14552
14553 /* Check if the object enable ex9. */
14554 irel = find_relocs_at_address (internal_relocs, internal_relocs,
14555 irelend, R_NDS32_RELAX_ENTRY);
14556
14557 /* Check this section trigger ex9 relaxation. */
14558 if (irel == NULL
14559 || irel >= irelend
14560 || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
14561 || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
14562 && !(irel->r_addend & R_NDS32_RELAX_ENTRY_EX9_FLAG)))
14563 return TRUE;
14564
14565 irel = internal_relocs;
14566
14567 /* Check alignment and fetch proper relocation. */
14568 while (off < sec->size)
14569 {
14570 struct elf_link_hash_entry *h = NULL;
14571 struct elf_nds32_irel_entry *irel_ptr = NULL;
14572
14573 /* Syn the instruction and the relocation. */
14574 while (irel != NULL && irel < irelend && irel->r_offset < off)
14575 irel++;
14576
14577 data_flag = nds32_elf_ex9_relocation_check (info, &irel, irelend,
14578 relax_blank_list, sec,
14579 &off, contents);
14580 if (data_flag & PUSH_PRE)
14581 if (!nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14582 &relax_blank_list, pre_irel_ptr,
14583 &irel_list))
14584 return FALSE;
14585
14586 if (data_flag & CLEAN_PRE)
14587 {
14588 pre_off = 0;
14589 pre_insn16 = 0;
14590 pre_irel_ptr = NULL;
14591 }
14592 if (data_flag & DATA_EXIST)
14593 {
14594 /* We save the move offset in the highest byte. */
14595 off += (data_flag >> 24);
14596 continue;
14597 }
14598
14599 if (*(contents + off) & 0x80)
14600 {
14601 /* 2-byte instruction. */
14602 off += 2;
14603 continue;
14604 }
14605
14606 /* Load the instruction and its opcode with register for comparing. */
14607 ex9_insn = ex9_insn_head;
14608 insn = bfd_getb32 (contents + off);
14609 insn_with_reg = 0;
14610 while (ex9_insn)
14611 {
14612 it_insn = strtol (ex9_insn->string, NULL, 16);
14613 it_insn_with_reg = 0;
14614 do_replace = 0;
14615 save_irel = 0;
14616
14617 if (irel != NULL && irel < irelend && irel->r_offset == off)
14618 {
14619 /* Insn with relocation. */
14620 nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
14621
14622 if (ex9_insn->irel != NULL)
14623 nds32_elf_get_insn_with_reg (ex9_insn->irel, it_insn,
14624 &it_insn_with_reg);
14625
14626 if (ex9_insn->irel != NULL
14627 && (ELF32_R_TYPE (irel->r_info) ==
14628 ELF32_R_TYPE (ex9_insn->irel->r_info))
14629 && (insn_with_reg == it_insn_with_reg))
14630 {
14631 /* Insn relocation and format is the same as table entry. */
14632
14633 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA
14634 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_ORI_RELA
14635 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_RELA
14636 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S1_RELA
14637 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_RELA
14638 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
14639 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
14640 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
14641 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
14642 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
14643 && ELF32_R_TYPE (irel->r_info) <=
14644 R_NDS32_SDA12S2_SP_RELA)
14645 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
14646 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
14647 {
14648 r_symndx = ELF32_R_SYM (irel->r_info);
14649 if (r_symndx < symtab_hdr->sh_info)
14650 {
14651 /* Local symbol. */
14652 int shndx = isym[r_symndx].st_shndx;
14653
14654 isec = elf_elfsections (abfd)[shndx]->bfd_section;
14655 if (ex9_insn->sec == isec
14656 && ex9_insn->irel->r_addend == irel->r_addend
14657 && ex9_insn->irel->r_info == irel->r_info)
14658 {
14659 do_replace = 1;
14660 save_irel = 1;
14661 }
14662 }
14663 else
14664 {
14665 /* External symbol. */
14666 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14667 if (ex9_insn->m_list)
14668 {
14669 h_list = ex9_insn->m_list->h_list;
14670 while (h_list)
14671 {
14672 if (h == h_list->h
14673 && (ex9_insn->m_list->irel->r_addend ==
14674 irel->r_addend))
14675 {
14676 do_replace = 1;
14677 save_irel = 1;
14678 break;
14679 }
14680 h_list = h_list->next;
14681 }
14682 }
14683 }
14684 }
14685 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_HI20_RELA)
14686 {
14687 r_symndx = ELF32_R_SYM (irel->r_info);
14688 if (r_symndx < symtab_hdr->sh_info)
14689 {
14690 /* Local symbols. Compare its base symbol and offset. */
14691 int shndx = isym[r_symndx].st_shndx;
14692
14693 isec = elf_elfsections (abfd)[shndx]->bfd_section;
14694 if (ex9_insn->sec == isec
14695 && ex9_insn->irel->r_addend == irel->r_addend
14696 && ex9_insn->irel->r_info == irel->r_info)
14697 {
14698 do_replace = 1;
14699 save_irel = 1;
14700 }
14701 }
14702 else
14703 {
14704 /* External symbol. */
14705 struct elf_link_hash_entry_mul_list *m_list;
14706
14707 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14708 m_list = ex9_insn->m_list;
14709
14710 while (m_list)
14711 {
14712 h_list = m_list->h_list;
14713
14714 while (h_list)
14715 {
14716 if (h == h_list->h
14717 && (m_list->irel->r_addend
14718 == irel->r_addend))
14719 {
14720 do_replace = 1;
14721 save_irel = 1;
14722 if (ex9_insn->next
14723 && ex9_insn->m_list
14724 && ex9_insn->m_list == ex9_insn->next->m_list)
14725 {
14726 /* sethi multiple entry must be fixed */
14727 nds32_elf_ex9_insert_fix (sec, irel,
14728 h, ex9_insn->order);
14729 }
14730 break;
14731 }
14732 h_list = h_list->next;
14733 }
14734 m_list = m_list->next;
14735 }
14736 }
14737 }
14738 }
14739
14740 /* Import table: Check the symbol hash table and the
14741 jump target. Only R_NDS32_25_PCREL_RELA now. */
14742 else if (ex9_insn->times == -1
14743 && ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA)
14744 {
14745 nds32_elf_get_insn_with_reg (irel, it_insn, &it_insn_with_reg);
14746 if (insn_with_reg == it_insn_with_reg)
14747 {
14748 char code[10];
14749 bfd_vma relocation;
14750
14751 r_symndx = ELF32_R_SYM (irel->r_info);
14752 if (r_symndx >= symtab_hdr->sh_info)
14753 {
14754 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
14755 if ((h->root.type == bfd_link_hash_defined
14756 || h->root.type == bfd_link_hash_defweak)
14757 && h->root.u.def.section != NULL
14758 && h->root.u.def.section->output_section != NULL
14759 && h->root.u.def.section->gc_mark == 1
14760 && bfd_is_abs_section (h->root.u.def.section)
14761 && h->root.u.def.value > sec->size)
14762 {
14763 relocation = h->root.u.def.value +
14764 h->root.u.def.section->output_section->vma +
14765 h->root.u.def.section->output_offset;
14766 relocation += irel->r_addend;
14767 insn = insn_with_reg
14768 | ((relocation >> 1) & 0xffffff);
14769 snprintf (code, sizeof (code), "%08x", insn);
14770 if (strcmp (code, ex9_insn->string) == 0)
14771 {
14772 do_replace = 1;
14773 save_irel = 1;
14774 }
14775 }
14776 }
14777 }
14778 }
14779 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
14780 || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
14781 || ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
14782 {
14783 /* These relocations do not have to relocate contens, so it can
14784 be regard as instruction without relocation. */
14785 if (insn == it_insn && ex9_insn->irel == NULL)
14786 do_replace = 1;
14787 }
14788 }
14789 else
14790 {
14791 /* Instruction without relocation, we only
14792 have to compare their byte code. */
14793 if (insn == it_insn && ex9_insn->irel == NULL)
14794 do_replace = 1;
14795 }
14796
14797 /* Insntruction match so replacing the code here. */
14798 if (do_replace == 1)
14799 {
14800 /* There are two formats of ex9 instruction. */
14801 if (ex9_insn->order < 32)
14802 insn_ex9 = INSN_EX9_IT_2;
14803 else
14804 insn_ex9 = INSN_EX9_IT_1;
14805 insn16 = insn_ex9 | ex9_insn->order;
14806
14807 /* Insert ex9 instruction. */
14808 nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14809 &relax_blank_list, pre_irel_ptr,
14810 &irel_list);
14811 pre_off = off;
14812 pre_insn16 = insn16;
14813
14814 if (save_irel)
14815 {
14816 /* For instuction with relocation do relax. */
14817 irel_ptr = (struct elf_nds32_irel_entry *)
14818 bfd_malloc (sizeof (struct elf_nds32_irel_entry));
14819 irel_ptr->irel = irel;
14820 irel_ptr->next = NULL;
14821 pre_irel_ptr = irel_ptr;
14822 }
14823 else
14824 pre_irel_ptr = NULL;
14825 break;
14826 }
14827 ex9_insn = ex9_insn->next;
14828 }
14829 off += 4;
14830 }
14831
14832 /* Insert ex9 instruction. */
14833 nds32_elf_ex9_push_insn (pre_insn16, contents, pre_off,
14834 &relax_blank_list, pre_irel_ptr,
14835 &irel_list);
14836
14837 /* Delete the redundant code. */
14838 if (relax_blank_list)
14839 {
14840 nds32_elf_relax_delete_blanks (abfd, sec, relax_blank_list);
14841 relax_blank_list = NULL;
14842 }
14843
14844 /* Clear the relocation that is replaced by ex9. */
14845 while (irel_list)
14846 {
14847 struct elf_nds32_irel_entry *irel_ptr;
14848
14849 irel_ptr = irel_list;
14850 irel_list = irel_ptr->next;
14851 irel_ptr->irel->r_info =
14852 ELF32_R_INFO (ELF32_R_SYM (irel_ptr->irel->r_info), R_NDS32_TRAN);
14853 free (irel_ptr);
14854 }
14855 return TRUE;
14856 }
14857
14858 /* Initialize ex9 hash table. */
14859
14860 int
14861 nds32_elf_ex9_init (void)
14862 {
14863 if (!bfd_hash_table_init_n (&ex9_code_table, nds32_elf_code_hash_newfunc,
14864 sizeof (struct elf_nds32_code_hash_entry),
14865 1023))
14866 {
14867 _bfd_error_handler (_("Linker: cannot init ex9 hash table error \n"));
14868 return FALSE;
14869 }
14870 return TRUE;
14871 }
14872
14873 /* Predict how many bytes will be relaxed with ex9 and ifc. */
14874
14875 static void
14876 nds32_elf_ex9_total_relax (struct bfd_link_info *info)
14877 {
14878 struct elf_nds32_insn_times_entry *ex9_insn;
14879 struct elf_nds32_insn_times_entry *temp;
14880 int target_optimize;
14881 struct elf_nds32_link_hash_table *table;
14882
14883 if (ex9_insn_head == NULL)
14884 return;
14885
14886 table = nds32_elf_hash_table (info);
14887 target_optimize = table->target_optimize;
14888 ex9_insn = ex9_insn_head;
14889 while (ex9_insn)
14890 {
14891 ex9_relax_size = ex9_insn->times * 2 + ex9_relax_size;
14892 temp = ex9_insn;
14893 ex9_insn = ex9_insn->next;
14894 free (temp);
14895 }
14896 ex9_insn_head = NULL;
14897
14898 if ((target_optimize & NDS32_RELAX_JUMP_IFC_ON))
14899 {
14900 /* Examine ifc reduce size. */
14901 struct elf_nds32_ifc_symbol_entry *ifc_ent = ifc_symbol_head;
14902 struct elf_nds32_ifc_irel_list *irel_ptr = NULL;
14903 int size = 0;
14904
14905 while (ifc_ent)
14906 {
14907 if (ifc_ent->enable == 0)
14908 {
14909 /* Not ifc yet. */
14910 irel_ptr = ifc_ent->irel_head;
14911 while (irel_ptr)
14912 {
14913 size += 2;
14914 irel_ptr = irel_ptr->next;
14915 }
14916 }
14917 size -= 2;
14918 ifc_ent = ifc_ent->next;
14919 }
14920 ex9_relax_size += size;
14921 }
14922 }
14923
14924 /* Finish ex9 table. */
14925
14926 void
14927 nds32_elf_ex9_finish (struct bfd_link_info *link_info)
14928 {
14929 nds32_elf_code_hash_traverse (nds32_elf_examine_insn_times);
14930 nds32_elf_order_insn_times (link_info);
14931 nds32_elf_ex9_total_relax (link_info);
14932 /* Traverse the hash table and count its times. */
14933 nds32_elf_code_hash_traverse (nds32_elf_count_insn_times);
14934 nds32_elf_order_insn_times (link_info);
14935 nds32_elf_ex9_build_itable (link_info);
14936 }
14937
14938 /* Relocate the entries in ex9 table. */
14939
14940 static bfd_vma
14941 nds32_elf_ex9_reloc_insn (struct elf_nds32_insn_times_entry *ptr,
14942 struct bfd_link_info *link_info)
14943 {
14944 Elf_Internal_Sym *isym = NULL;
14945 bfd_vma relocation = -1;
14946 struct elf_link_hash_entry *h;
14947
14948 if (ptr->m_list != NULL)
14949 {
14950 /* Global symbol. */
14951 h = ptr->m_list->h_list->h;
14952 if ((h->root.type == bfd_link_hash_defined
14953 || h->root.type == bfd_link_hash_defweak)
14954 && h->root.u.def.section != NULL
14955 && h->root.u.def.section->output_section != NULL)
14956 {
14957
14958 relocation = h->root.u.def.value +
14959 h->root.u.def.section->output_section->vma +
14960 h->root.u.def.section->output_offset;
14961 relocation += ptr->m_list->irel->r_addend;
14962 }
14963 else
14964 relocation = 0;
14965 }
14966 else if (ptr->sec !=NULL)
14967 {
14968 /* Local symbol. */
14969 Elf_Internal_Sym sym;
14970 asection *sec = NULL;
14971 asection isec;
14972 asection *isec_ptr = &isec;
14973 Elf_Internal_Rela irel_backup = *(ptr->irel);
14974 asection *sec_backup = ptr->sec;
14975 bfd *abfd = ptr->sec->owner;
14976
14977 if (!nds32_get_local_syms (abfd, sec, &isym))
14978 return FALSE;
14979 isym = isym + ELF32_R_SYM (ptr->irel->r_info);
14980
14981 sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
14982 if (sec != NULL)
14983 *isec_ptr = *sec;
14984 sym = *isym;
14985
14986 /* The purpose is same as elf_link_input_bfd. */
14987 if (isec_ptr != NULL
14988 && isec_ptr->sec_info_type == SEC_INFO_TYPE_MERGE
14989 && ELF_ST_TYPE (isym->st_info) != STT_SECTION)
14990 {
14991 sym.st_value =
14992 _bfd_merged_section_offset (ptr->sec->output_section->owner, &isec_ptr,
14993 elf_section_data (isec_ptr)->sec_info,
14994 isym->st_value);
14995 }
14996 relocation = _bfd_elf_rela_local_sym (link_info->output_bfd, &sym,
14997 &ptr->sec, ptr->irel);
14998 if (ptr->irel != NULL)
14999 relocation += ptr->irel->r_addend;
15000
15001 /* Restore origin value since there may be some insntructions that
15002 could not be replaced with ex9.it. */
15003 *(ptr->irel) = irel_backup;
15004 ptr->sec = sec_backup;
15005 }
15006
15007 return relocation;
15008 }
15009
15010 /* Import ex9 table and build list. */
15011
15012 void
15013 nds32_elf_ex9_import_table (struct bfd_link_info *info)
15014 {
15015 int num = 0;
15016 bfd_byte *contents;
15017 unsigned long insn;
15018 FILE *ex9_import_file;
15019 int update_ex9_table;
15020 struct elf_nds32_link_hash_table *table;
15021
15022 table = nds32_elf_hash_table (info);
15023 ex9_import_file = table->ex9_import_file;
15024 rewind (table->ex9_import_file);
15025
15026 contents = bfd_malloc (sizeof (bfd_byte) * 4);
15027
15028 /* Read instructions from the input file and build the list. */
15029 while (!feof (ex9_import_file))
15030 {
15031 char *code;
15032 struct elf_nds32_insn_times_entry *ptr;
15033 size_t nread;
15034
15035 nread = fread (contents, sizeof (bfd_byte) * 4, 1, ex9_import_file);
15036 /* Ignore the final byte 0x0a. */
15037 if (nread < 1)
15038 break;
15039 insn = bfd_getb32 (contents);
15040 code = bfd_malloc (sizeof (char) * 9);
15041 snprintf (code, 9, "%08lx", insn);
15042 ptr = bfd_malloc (sizeof (struct elf_nds32_insn_times_entry));
15043 ptr->string = code;
15044 ptr->order = num;
15045 ptr->times = -1;
15046 ptr->sec = NULL;
15047 ptr->m_list = NULL;
15048 ptr->rel_backup.r_offset = 0;
15049 ptr->rel_backup.r_info = 0;
15050 ptr->rel_backup.r_addend = 0;
15051 ptr->irel = NULL;
15052 ptr->next = NULL;
15053 nds32_elf_ex9_insert_entry (ptr);
15054 num++;
15055 }
15056
15057 update_ex9_table = table->update_ex9_table;
15058 if (update_ex9_table == 1)
15059 {
15060 /* It has to consider of sethi need to use multiple page
15061 but it not be done yet. */
15062 nds32_elf_code_hash_traverse (nds32_elf_examine_insn_times);
15063 nds32_elf_order_insn_times (info);
15064 }
15065 }
15066
15067 /* Export ex9 table. */
15068
15069 static void
15070 nds32_elf_ex9_export (struct bfd_link_info *info,
15071 bfd_byte *contents, int size)
15072 {
15073 FILE *ex9_export_file;
15074 struct elf_nds32_link_hash_table *table;
15075
15076 table = nds32_elf_hash_table (info);
15077 ex9_export_file = table->ex9_export_file;
15078 fwrite (contents, sizeof (bfd_byte), size, ex9_export_file);
15079 fclose (ex9_export_file);
15080 }
15081
15082 /* Adjust relocations of J and JAL in ex9.itable.
15083 Export ex9 table. */
15084
15085 static void
15086 nds32_elf_ex9_reloc_jmp (struct bfd_link_info *link_info)
15087 {
15088 asection *table_sec = NULL;
15089 struct elf_nds32_insn_times_entry *ex9_insn = ex9_insn_head;
15090 struct elf_nds32_insn_times_entry *temp_ptr, *temp_ptr2;
15091 bfd *it_abfd;
15092 uint32_t insn, insn_with_reg, source_insn;
15093 bfd_byte *contents = NULL, *source_contents = NULL;
15094 int size = 0;
15095 bfd_vma gp;
15096 int shift, update_ex9_table, offset = 0;
15097 reloc_howto_type *howto = NULL;
15098 Elf_Internal_Rela rel_backup;
15099 unsigned short insn_ex9;
15100 struct elf_nds32_link_hash_table *table;
15101 FILE *ex9_export_file;
15102 static bfd_boolean done = FALSE;
15103
15104 if (done)
15105 return;
15106
15107 done = TRUE;
15108
15109 table = nds32_elf_hash_table (link_info);
15110 if (table)
15111 table->relax_status |= NDS32_RELAX_EX9_DONE;
15112
15113
15114 update_ex9_table = table->update_ex9_table;
15115 /* Generated ex9.itable exactly. */
15116 if (update_ex9_table == 0)
15117 {
15118 for (it_abfd = link_info->input_bfds; it_abfd != NULL;
15119 it_abfd = it_abfd->link.next)
15120 {
15121 table_sec = bfd_get_section_by_name (it_abfd, ".ex9.itable");
15122 if (table_sec != NULL)
15123 break;
15124 }
15125
15126 if (table_sec != NULL)
15127 {
15128 bfd *output_bfd;
15129
15130 output_bfd = table_sec->output_section->owner;
15131 nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
15132 if (table_sec->size == 0)
15133 return;
15134
15135 if (!nds32_get_section_contents (it_abfd, table_sec, &contents, TRUE))
15136 return;
15137 }
15138 }
15139 else
15140 {
15141 /* Set gp. */
15142 bfd *output_bfd;
15143
15144 output_bfd = link_info->input_bfds->sections->output_section->owner;
15145 nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
15146 contents = bfd_malloc (sizeof (bfd_byte) * 2048);
15147 }
15148
15149 /* Relocate instruction. */
15150 while (ex9_insn)
15151 {
15152 bfd_vma relocation, min_relocation = 0xffffffff;
15153
15154 insn = strtol (ex9_insn->string, NULL, 16);
15155 insn_with_reg = 0;
15156 if (ex9_insn->m_list != NULL || ex9_insn->sec != NULL)
15157 {
15158 if (ex9_insn->m_list)
15159 rel_backup = ex9_insn->m_list->rel_backup;
15160 else
15161 rel_backup = ex9_insn->rel_backup;
15162
15163 nds32_elf_get_insn_with_reg (&rel_backup, insn, &insn_with_reg);
15164 howto =
15165 bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE
15166 (rel_backup.r_info));
15167 shift = howto->rightshift;
15168 if (ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_25_PCREL_RELA
15169 || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S0_ORI_RELA
15170 || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S0_RELA
15171 || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S1_RELA
15172 || ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_LO12S2_RELA)
15173 {
15174 relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
15175 insn =
15176 insn_with_reg | ((relocation >> shift) &
15177 nds32_elf_irel_mask (&rel_backup));
15178 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15179 }
15180 else if ((ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA15S3
15181 && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA15S0)
15182 || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA15S3_RELA
15183 && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA15S0_RELA)
15184 || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA12S2_DP_RELA
15185 && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA12S2_SP_RELA)
15186 || (ELF32_R_TYPE (rel_backup.r_info) >= R_NDS32_SDA16S3_RELA
15187 && ELF32_R_TYPE (rel_backup.r_info) <= R_NDS32_SDA19S0_RELA))
15188 {
15189 relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
15190 insn =
15191 insn_with_reg | (((relocation - gp) >> shift) &
15192 nds32_elf_irel_mask (&rel_backup));
15193 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15194 }
15195 else if (ELF32_R_TYPE (rel_backup.r_info) == R_NDS32_HI20_RELA)
15196 {
15197 /* Sethi may be multiple entry for one insn. */
15198 if (ex9_insn->next && ex9_insn->m_list
15199 && ex9_insn->m_list == ex9_insn->next->m_list)
15200 {
15201 struct elf_link_hash_entry_mul_list *m_list;
15202 struct elf_nds32_ex9_refix *fix_ptr;
15203 struct elf_link_hash_entry *h;
15204
15205 temp_ptr = ex9_insn;
15206 temp_ptr2 = ex9_insn;
15207 m_list = ex9_insn->m_list;
15208 while (m_list)
15209 {
15210 h = m_list->h_list->h;
15211 relocation = h->root.u.def.value +
15212 h->root.u.def.section->output_section->vma +
15213 h->root.u.def.section->output_offset;
15214 relocation += m_list->irel->r_addend;
15215
15216 if (relocation < min_relocation)
15217 min_relocation = relocation;
15218 m_list = m_list->next;
15219 }
15220 relocation = min_relocation;
15221
15222 /* Put insntruction into ex9 table. */
15223 insn = insn_with_reg
15224 | ((relocation >> shift) & nds32_elf_irel_mask (&rel_backup));
15225 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15226 relocation = relocation + 0x1000; /* hi20 */
15227
15228 while (ex9_insn->next && ex9_insn->m_list
15229 && ex9_insn->m_list == ex9_insn->next->m_list)
15230 {
15231 /* Multiple sethi. */
15232 ex9_insn = ex9_insn->next;
15233 size += 4;
15234 insn =
15235 insn_with_reg | ((relocation >> shift) &
15236 nds32_elf_irel_mask (&rel_backup));
15237 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15238 relocation = relocation + 0x1000; /* hi20 */
15239 }
15240
15241 fix_ptr = ex9_refix_head;
15242 while (fix_ptr)
15243 {
15244 /* Fix ex9 insn. */
15245 /* temp_ptr2 points to the head of multiple sethi. */
15246 temp_ptr = temp_ptr2;
15247 while (fix_ptr->order != temp_ptr->order && fix_ptr->next)
15248 {
15249 fix_ptr = fix_ptr->next;
15250 }
15251 if (fix_ptr->order != temp_ptr->order)
15252 break;
15253
15254 /* Set source insn. */
15255 relocation =
15256 fix_ptr->h->root.u.def.value +
15257 fix_ptr->h->root.u.def.section->output_section->vma +
15258 fix_ptr->h->root.u.def.section->output_offset;
15259 relocation += fix_ptr->irel->r_addend;
15260 /* sethi imm is imm20s. */
15261 source_insn = insn_with_reg | ((relocation >> shift) & 0xfffff);
15262
15263 while (temp_ptr)
15264 {
15265 /* Match entry and source code. */
15266 insn = bfd_getb32 (contents + (temp_ptr->order) * 4 + offset);
15267 if (insn == source_insn)
15268 {
15269 /* Fix the ex9 insn. */
15270 if (temp_ptr->order != fix_ptr->order)
15271 {
15272 if (!nds32_get_section_contents
15273 (fix_ptr->sec->owner, fix_ptr->sec,
15274 &source_contents, TRUE))
15275 _bfd_error_handler
15276 (_("Linker: error cannot fixed ex9 relocation \n"));
15277 if (temp_ptr->order < 32)
15278 insn_ex9 = INSN_EX9_IT_2;
15279 else
15280 insn_ex9 = INSN_EX9_IT_1;
15281 insn_ex9 = insn_ex9 | temp_ptr->order;
15282 bfd_putb16 (insn_ex9, source_contents + fix_ptr->irel->r_offset);
15283 }
15284 break;
15285 }
15286 else
15287 {
15288 if (!temp_ptr->next || temp_ptr->m_list != temp_ptr->next->m_list)
15289 _bfd_error_handler
15290 (_("Linker: error cannot fixed ex9 relocation \n"));
15291 else
15292 temp_ptr = temp_ptr->next;
15293 }
15294 }
15295 fix_ptr = fix_ptr->next;
15296 }
15297 }
15298 else
15299 {
15300 relocation = nds32_elf_ex9_reloc_insn (ex9_insn, link_info);
15301 insn = insn_with_reg
15302 | ((relocation >> shift) & nds32_elf_irel_mask (&rel_backup));
15303 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15304 }
15305 }
15306 }
15307 else
15308 {
15309 /* Insn without relocation does not have to be fixed
15310 if need to update export table. */
15311 if (update_ex9_table == 1)
15312 bfd_putb32 (insn, contents + (ex9_insn->order) * 4);
15313 }
15314 ex9_insn = ex9_insn->next;
15315 size += 4;
15316 }
15317
15318 ex9_export_file = table->ex9_export_file;
15319 if (ex9_export_file != NULL)
15320 nds32_elf_ex9_export (link_info, contents, table_sec->size);
15321 else if (update_ex9_table == 1)
15322 {
15323 table->ex9_export_file = table->ex9_import_file;
15324 rewind (table->ex9_export_file);
15325 nds32_elf_ex9_export (link_info, contents, size);
15326 }
15327 }
15328
15329 /* Generate ex9 hash table. */
15330
15331 static bfd_boolean
15332 nds32_elf_ex9_build_hash_table (bfd *abfd, asection *sec,
15333 struct bfd_link_info *link_info)
15334 {
15335 Elf_Internal_Rela *internal_relocs;
15336 Elf_Internal_Rela *irelend;
15337 Elf_Internal_Rela *irel;
15338 Elf_Internal_Rela *jrel;
15339 Elf_Internal_Rela rel_backup;
15340 Elf_Internal_Shdr *symtab_hdr;
15341 Elf_Internal_Sym *isym = NULL;
15342 asection *isec;
15343 struct elf_link_hash_entry **sym_hashes;
15344 bfd_byte *contents = NULL;
15345 bfd_vma off = 0;
15346 unsigned long r_symndx;
15347 uint32_t insn, insn_with_reg;
15348 struct elf_link_hash_entry *h;
15349 int data_flag, shift, align;
15350 bfd_vma relocation;
15351 /* Suppress ex9 if `.no_relax ex9' or inner loop. */
15352 reloc_howto_type *howto = NULL;
15353
15354 sym_hashes = elf_sym_hashes (abfd);
15355 /* Load section instructions, relocations, and symbol table. */
15356 if (!nds32_get_section_contents (abfd, sec, &contents, TRUE))
15357 return FALSE;
15358
15359 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
15360 TRUE /* keep_memory */);
15361 irelend = internal_relocs + sec->reloc_count;
15362 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
15363 if (!nds32_get_local_syms (abfd, sec, &isym))
15364 return FALSE;
15365
15366 /* Check the object if enable ex9. */
15367 irel = find_relocs_at_address (internal_relocs, internal_relocs, irelend,
15368 R_NDS32_RELAX_ENTRY);
15369
15370 /* Check this section trigger ex9 relaxation. */
15371 if (irel == NULL
15372 || irel >= irelend
15373 || ELF32_R_TYPE (irel->r_info) != R_NDS32_RELAX_ENTRY
15374 || (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_ENTRY
15375 && !(irel->r_addend & R_NDS32_RELAX_ENTRY_EX9_FLAG)))
15376 return TRUE;
15377
15378 irel = internal_relocs;
15379
15380 /* Push each insn into hash table. */
15381 while (off < sec->size)
15382 {
15383 char code[10];
15384 struct elf_nds32_code_hash_entry *entry;
15385
15386 while (irel != NULL && irel < irelend && irel->r_offset < off)
15387 irel++;
15388
15389 data_flag = nds32_elf_ex9_relocation_check (link_info, &irel, irelend,
15390 NULL, sec, &off, contents);
15391 if (data_flag & DATA_EXIST)
15392 {
15393 /* We save the move offset in the highest byte. */
15394 off += (data_flag >> 24);
15395 continue;
15396 }
15397
15398 if (*(contents + off) & 0x80)
15399 {
15400 off += 2;
15401 }
15402 else
15403 {
15404 h = NULL;
15405 isec = NULL;
15406 jrel = NULL;
15407 rel_backup.r_info = 0;
15408 rel_backup.r_offset = 0;
15409 rel_backup.r_addend = 0;
15410 /* Load the instruction and its opcode with register for comparing. */
15411 insn = bfd_getb32 (contents + off);
15412 insn_with_reg = 0;
15413 if (irel != NULL && irel < irelend && irel->r_offset == off)
15414 {
15415 nds32_elf_get_insn_with_reg (irel, insn, &insn_with_reg);
15416 howto = bfd_elf32_bfd_reloc_type_table_lookup (ELF32_R_TYPE (irel->r_info));
15417 shift = howto->rightshift;
15418 align = (1 << shift) - 1;
15419 if (ELF32_R_TYPE (irel->r_info) == R_NDS32_25_PCREL_RELA
15420 || ELF32_R_TYPE (irel->r_info) == R_NDS32_HI20_RELA
15421 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_ORI_RELA
15422 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S0_RELA
15423 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S1_RELA
15424 || ELF32_R_TYPE (irel->r_info) == R_NDS32_LO12S2_RELA
15425 ||(ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
15426 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
15427 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
15428 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
15429 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
15430 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA12S2_SP_RELA)
15431 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
15432 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
15433 {
15434 r_symndx = ELF32_R_SYM (irel->r_info);
15435 jrel = irel;
15436 rel_backup = *irel;
15437 if (r_symndx < symtab_hdr->sh_info)
15438 {
15439 /* Local symbol. */
15440 int shndx = isym[r_symndx].st_shndx;
15441
15442 bfd_vma st_value = (isym + r_symndx)->st_value;
15443 isec = elf_elfsections (abfd)[shndx]->bfd_section;
15444 relocation = (isec->output_section->vma + isec->output_offset
15445 + st_value + irel->r_addend);
15446 }
15447 else
15448 {
15449 /* External symbol. */
15450 bfd_boolean warned ATTRIBUTE_UNUSED;
15451 bfd_boolean ignored ATTRIBUTE_UNUSED;
15452 bfd_boolean unresolved_reloc ATTRIBUTE_UNUSED;
15453 asection *sym_sec;
15454
15455 /* Maybe there is a better way to get h and relocation */
15456 RELOC_FOR_GLOBAL_SYMBOL (link_info, abfd, sec, irel,
15457 r_symndx, symtab_hdr, sym_hashes,
15458 h, sym_sec, relocation,
15459 unresolved_reloc, warned, ignored);
15460 relocation += irel->r_addend;
15461 if ((h->root.type != bfd_link_hash_defined
15462 && h->root.type != bfd_link_hash_defweak)
15463 || strcmp (h->root.root.string, "_FP_BASE_") == 0)
15464 {
15465 off += 4;
15466 continue;
15467 }
15468 }
15469
15470 /* Check for gp relative instruction alignment. */
15471 if ((ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3
15472 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0)
15473 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA15S3_RELA
15474 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA15S0_RELA)
15475 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA12S2_DP_RELA
15476 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA12S2_SP_RELA)
15477 || (ELF32_R_TYPE (irel->r_info) >= R_NDS32_SDA16S3_RELA
15478 && ELF32_R_TYPE (irel->r_info) <= R_NDS32_SDA19S0_RELA))
15479 {
15480 bfd_vma gp;
15481 bfd *output_bfd = sec->output_section->owner;
15482 bfd_reloc_status_type r;
15483
15484 /* If the symbol is in the abs section, the out_bfd will be null.
15485 This happens when the relocation has a symbol@GOTOFF. */
15486 r = nds32_elf_final_sda_base (output_bfd, link_info, &gp, FALSE);
15487 if (r != bfd_reloc_ok)
15488 {
15489 off += 4;
15490 continue;
15491 }
15492
15493 relocation -= gp;
15494
15495 /* Make sure alignment is correct. */
15496 if (relocation & align)
15497 {
15498 /* Incorrect alignment. */
15499 _bfd_error_handler
15500 (_("%s: warning: unaligned small data access. "
15501 "For entry: {%d, %d, %d}, addr = 0x%x, align = 0x%x."),
15502 bfd_get_filename (abfd), irel->r_offset,
15503 irel->r_info, irel->r_addend, relocation, align);
15504 off += 4;
15505 continue;
15506 }
15507 }
15508
15509 insn = insn_with_reg
15510 | ((relocation >> shift) & nds32_elf_irel_mask (irel));
15511 }
15512 else if (ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_BEGIN
15513 || ELF32_R_TYPE (irel->r_info) == R_NDS32_RELAX_REGION_END
15514 || ELF32_R_TYPE (irel->r_info) == R_NDS32_NONE)
15515 {
15516 /* These relocations do not have to relocate contens, so it can
15517 be regard as instruction without relocation. */
15518 }
15519 else
15520 {
15521 off += 4;
15522 continue;
15523 }
15524 }
15525
15526 snprintf (code, sizeof (code), "%08x", insn);
15527 /* Copy "code". */
15528 entry = (struct elf_nds32_code_hash_entry*)
15529 bfd_hash_lookup (&ex9_code_table, code, TRUE, TRUE);
15530 if (entry == NULL)
15531 {
15532 _bfd_error_handler
15533 (_("%P%F: failed creating ex9.it %s hash table: %E\n"), code);
15534 return FALSE;
15535 }
15536 if (h)
15537 {
15538 if (h->root.type == bfd_link_hash_undefined)
15539 return TRUE;
15540 /* Global symbol. */
15541 /* In order to do sethi with different symbol but same value. */
15542 if (entry->m_list == NULL)
15543 {
15544 struct elf_link_hash_entry_mul_list *m_list_new;
15545 struct elf_link_hash_entry_list *h_list_new;
15546
15547 m_list_new = (struct elf_link_hash_entry_mul_list *)
15548 bfd_malloc (sizeof (struct elf_link_hash_entry_mul_list));
15549 h_list_new = (struct elf_link_hash_entry_list *)
15550 bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15551 entry->m_list = m_list_new;
15552 m_list_new->h_list = h_list_new;
15553 m_list_new->rel_backup = rel_backup;
15554 m_list_new->times = 1;
15555 m_list_new->irel = jrel;
15556 m_list_new->next = NULL;
15557 h_list_new->h = h;
15558 h_list_new->next = NULL;
15559 }
15560 else
15561 {
15562 struct elf_link_hash_entry_mul_list *m_list = entry->m_list;
15563 struct elf_link_hash_entry_list *h_list;
15564
15565 while (m_list)
15566 {
15567 /* Build the different symbols that point to the same address. */
15568 h_list = m_list->h_list;
15569 if (h_list->h->root.u.def.value == h->root.u.def.value
15570 && h_list->h->root.u.def.section->output_section->vma
15571 == h->root.u.def.section->output_section->vma
15572 && h_list->h->root.u.def.section->output_offset
15573 == h->root.u.def.section->output_offset
15574 && m_list->rel_backup.r_addend == rel_backup.r_addend)
15575 {
15576 m_list->times++;
15577 m_list->irel = jrel;
15578 while (h_list->h != h && h_list->next)
15579 h_list = h_list->next;
15580 if (h_list->h != h)
15581 {
15582 struct elf_link_hash_entry_list *h_list_new;
15583
15584 h_list_new = (struct elf_link_hash_entry_list *)
15585 bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15586 h_list->next = h_list_new;
15587 h_list_new->h = h;
15588 h_list_new->next = NULL;
15589 }
15590 break;
15591 }
15592 /* The sethi case may have different address but the
15593 hi20 is the same. */
15594 else if (ELF32_R_TYPE (jrel->r_info) == R_NDS32_HI20_RELA
15595 && m_list->next == NULL)
15596 {
15597 struct elf_link_hash_entry_mul_list *m_list_new;
15598 struct elf_link_hash_entry_list *h_list_new;
15599
15600 m_list_new = (struct elf_link_hash_entry_mul_list *)
15601 bfd_malloc (sizeof (struct elf_link_hash_entry_mul_list));
15602 h_list_new = (struct elf_link_hash_entry_list *)
15603 bfd_malloc (sizeof (struct elf_link_hash_entry_list));
15604 m_list->next = m_list_new;
15605 m_list_new->h_list = h_list_new;
15606 m_list_new->rel_backup = rel_backup;
15607 m_list_new->times = 1;
15608 m_list_new->irel = jrel;
15609 m_list_new->next = NULL;
15610 h_list_new->h = h;
15611 h_list_new->next = NULL;
15612 break;
15613 }
15614 m_list = m_list->next;
15615 }
15616 if (!m_list)
15617 {
15618 off += 4;
15619 continue;
15620 }
15621 }
15622 }
15623 else
15624 {
15625 /* Local symbol and insn without relocation*/
15626 entry->times++;
15627 entry->rel_backup = rel_backup;
15628 }
15629
15630 /* Use in sethi insn with constant and global symbol in same format. */
15631 if (!jrel)
15632 entry->const_insn = 1;
15633 else
15634 entry->irel = jrel;
15635 entry->sec = isec;
15636 off += 4;
15637 }
15638 }
15639 return TRUE;
15640 }
15641
15642 /* Set the _ITB_BASE, and point it to ex9 table. */
15643
15644 bfd_boolean
15645 nds32_elf_ex9_itb_base (struct bfd_link_info *link_info)
15646 {
15647 bfd *abfd;
15648 asection *sec;
15649 bfd *output_bfd = NULL;
15650 struct bfd_link_hash_entry *bh = NULL;
15651
15652 if (is_ITB_BASE_set == 1)
15653 return TRUE;
15654
15655 is_ITB_BASE_set = 1;
15656
15657 bh = bfd_link_hash_lookup (link_info->hash, "_ITB_BASE_", FALSE, FALSE, TRUE);
15658
15659 if (bh && (bh->type == bfd_link_hash_defined
15660 || bh->type == bfd_link_hash_defweak))
15661 return TRUE;
15662
15663 for (abfd = link_info->input_bfds; abfd != NULL;
15664 abfd = abfd->link.next)
15665 {
15666 sec = bfd_get_section_by_name (abfd, ".ex9.itable");
15667 if (sec != NULL)
15668 {
15669 output_bfd = sec->output_section->owner;
15670 break;
15671 }
15672 }
15673 if (output_bfd == NULL)
15674 {
15675 output_bfd = link_info->output_bfd;
15676 if (output_bfd->sections == NULL)
15677 return TRUE;
15678 else
15679 sec = bfd_abs_section_ptr;
15680 }
15681 bh = bfd_link_hash_lookup (link_info->hash, "_ITB_BASE_",
15682 FALSE, FALSE, TRUE);
15683 return (_bfd_generic_link_add_one_symbol
15684 (link_info, output_bfd, "_ITB_BASE_",
15685 BSF_GLOBAL | BSF_WEAK, sec, 0,
15686 (const char *) NULL, FALSE, get_elf_backend_data
15687 (output_bfd)->collect, &bh));
15688 } /* End EX9.IT */
15689 \f
15690
15691 #define ELF_ARCH bfd_arch_nds32
15692 #define ELF_MACHINE_CODE EM_NDS32
15693 #define ELF_MAXPAGESIZE 0x1000
15694 #define ELF_TARGET_ID NDS32_ELF_DATA
15695
15696 #define TARGET_BIG_SYM nds32_elf32_be_vec
15697 #define TARGET_BIG_NAME "elf32-nds32be"
15698 #define TARGET_LITTLE_SYM nds32_elf32_le_vec
15699 #define TARGET_LITTLE_NAME "elf32-nds32le"
15700
15701 #define elf_info_to_howto nds32_info_to_howto
15702 #define elf_info_to_howto_rel nds32_info_to_howto_rel
15703
15704 #define bfd_elf32_bfd_link_hash_table_create nds32_elf_link_hash_table_create
15705 #define bfd_elf32_bfd_merge_private_bfd_data nds32_elf_merge_private_bfd_data
15706 #define bfd_elf32_bfd_print_private_bfd_data nds32_elf_print_private_bfd_data
15707 #define bfd_elf32_bfd_relax_section nds32_elf_relax_section
15708 #define bfd_elf32_bfd_set_private_flags nds32_elf_set_private_flags
15709
15710 #define bfd_elf32_mkobject nds32_elf_mkobject
15711 #define elf_backend_action_discarded nds32_elf_action_discarded
15712 #define elf_backend_add_symbol_hook nds32_elf_add_symbol_hook
15713 #define elf_backend_check_relocs nds32_elf_check_relocs
15714 #define elf_backend_adjust_dynamic_symbol nds32_elf_adjust_dynamic_symbol
15715 #define elf_backend_create_dynamic_sections nds32_elf_create_dynamic_sections
15716 #define elf_backend_finish_dynamic_sections nds32_elf_finish_dynamic_sections
15717 #define elf_backend_finish_dynamic_symbol nds32_elf_finish_dynamic_symbol
15718 #define elf_backend_size_dynamic_sections nds32_elf_size_dynamic_sections
15719 #define elf_backend_relocate_section nds32_elf_relocate_section
15720 #define elf_backend_gc_mark_hook nds32_elf_gc_mark_hook
15721 #define elf_backend_gc_sweep_hook nds32_elf_gc_sweep_hook
15722 #define elf_backend_grok_prstatus nds32_elf_grok_prstatus
15723 #define elf_backend_grok_psinfo nds32_elf_grok_psinfo
15724 #define elf_backend_reloc_type_class nds32_elf_reloc_type_class
15725 #define elf_backend_copy_indirect_symbol nds32_elf_copy_indirect_symbol
15726 #define elf_backend_link_output_symbol_hook nds32_elf_output_symbol_hook
15727 #define elf_backend_output_arch_syms nds32_elf_output_arch_syms
15728 #define elf_backend_object_p nds32_elf_object_p
15729 #define elf_backend_final_write_processing nds32_elf_final_write_processing
15730 #define elf_backend_special_sections nds32_elf_special_sections
15731 #define bfd_elf32_bfd_get_relocated_section_contents \
15732 nds32_elf_get_relocated_section_contents
15733
15734 #define elf_backend_can_gc_sections 1
15735 #define elf_backend_can_refcount 1
15736 #define elf_backend_want_got_plt 1
15737 #define elf_backend_plt_readonly 1
15738 #define elf_backend_want_plt_sym 0
15739 #define elf_backend_got_header_size 12
15740 #define elf_backend_may_use_rel_p 1
15741 #define elf_backend_default_use_rela_p 1
15742 #define elf_backend_may_use_rela_p 1
15743
15744 #include "elf32-target.h"
15745
15746 #undef ELF_MAXPAGESIZE
15747 #define ELF_MAXPAGESIZE 0x2000
15748
15749 #undef TARGET_BIG_SYM
15750 #define TARGET_BIG_SYM nds32_elf32_linux_be_vec
15751 #undef TARGET_BIG_NAME
15752 #define TARGET_BIG_NAME "elf32-nds32be-linux"
15753 #undef TARGET_LITTLE_SYM
15754 #define TARGET_LITTLE_SYM nds32_elf32_linux_le_vec
15755 #undef TARGET_LITTLE_NAME
15756 #define TARGET_LITTLE_NAME "elf32-nds32le-linux"
15757 #undef elf32_bed
15758 #define elf32_bed elf32_nds32_lin_bed
15759
15760 #include "elf32-target.h"