?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: Support x86 Zhaoxin PadLock XMODX instructions
[binutils-gdb.git] / bfd / elf32-csky.c
blobdbb603b88bcfed31218690216b8b09b736b03db8
1 /* 32-bit ELF support for C-SKY.
2 Copyright (C) 1998-2025 Free Software Foundation, Inc.
3 Contributed by C-SKY Microsystems and Mentor Graphics.
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,
20 MA 02110-1301, USA. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "bfdlink.h"
25 #include "libbfd.h"
26 #include "elf-bfd.h"
27 #include "elf/csky.h"
28 #include "opcode/csky.h"
29 #include <assert.h>
30 #include "libiberty.h"
31 #include "elf32-csky.h"
32
33 /* Data structures used for merging different arch variants.
34 V1 (510/610) and V2 (8xx) processors are incompatible, but
35 we can merge wthin each family. */
36
37 enum merge_class
38 {
39 CSKY_V1,
40 CSKY_V2
41 };
42
43 typedef const struct csky_arch_for_merge
44 {
45 const char *name;
46 const unsigned long arch_eflag;
47 /* The files can merge only if they are in same class. */
48 enum merge_class class;
49 /* When input files have different levels,
50 the target sets arch_eflag to the largest level file's arch_eflag. */
51 unsigned int class_level;
52 /* Control whether to print warning when merging with different arch. */
53 unsigned int do_warning;
54 } csky_arch_for_merge;
55
56 static csky_arch_for_merge csky_archs[] =
57 {
58 /* 510 and 610 merge to 610 without warning. */
59 { "ck510", CSKY_ARCH_510, CSKY_V1, 0, 0},
60 { "ck610", CSKY_ARCH_610, CSKY_V1, 1, 0},
61 /* 801, 802, 803, 807, 810 merge to largest one. */
62 { "ck801", CSKY_ARCH_801, CSKY_V2, 0, 1},
63 { "ck802", CSKY_ARCH_802, CSKY_V2, 1, 1},
64 { "ck803", CSKY_ARCH_803, CSKY_V2, 2, 1},
65 { "ck807", CSKY_ARCH_807, CSKY_V2, 3, 1},
66 { "ck810", CSKY_ARCH_810, CSKY_V2, 4, 1},
67 { "ck860", CSKY_ARCH_860, CSKY_V2, 5, 1},
68 { NULL, 0, 0, 0, 0}
69 };
70
71 /* Return the ARCH bits out of ABFD. */
72 #define bfd_csky_arch(abfd) \
73 (elf_elfheader (abfd)->e_flags & CSKY_ARCH_MASK)
74
75 /* Return the ABI bits out of ABFD. */
76 #define bfd_csky_abi(abfd) \
77 (elf_elfheader (abfd)->e_flags & CSKY_ABI_MASK)
78
79
80 /* The index of a howto-item is implicitly equal to
81 the corresponding Relocation Type Encoding. */
82 static reloc_howto_type csky_elf_howto_table[] =
83 {
84 /* 0 */
85 HOWTO (R_CKCORE_NONE, /* type */
86 0, /* rightshift */
87 0, /* size */
88 0, /* bitsize */
89 false, /* pc_relative */
90 0, /* bitpos */
91 complain_overflow_dont, /* complain_on_overflow */
92 NULL, /* special_function */
93 "R_CKCORE_NONE", /* name */
94 false, /* partial_inplace */
95 0, /* src_mask */
96 0, /* dst_mask */
97 false), /* pcrel_offset */
98
99 /* 1. */
100 HOWTO (R_CKCORE_ADDR32, /* type */
101 0, /* rightshift */
102 4, /* size */
103 32, /* bitsize */
104 false, /* pc_relative */
105 0, /* bitpos */
106 complain_overflow_dont, /* complain_on_overflow */
107 bfd_elf_generic_reloc, /* special_function */
108 "R_CKCORE_ADDR32", /* name */
109 false, /* partial_inplace */
110 0, /* src_mask */
111 0xffffffff, /* dst_mask */
112 false), /* pcrel_offset */
113
114 /* 2: Only for csky v1. */
115 HOWTO (R_CKCORE_PCREL_IMM8BY4, /* type */
116 2, /* rightshift */
117 2, /* size */
118 8, /* bitsize */
119 true, /* pc_relative */
120 0, /* bitpos */
121 complain_overflow_bitfield, /* complain_on_overflow */
122 NULL, /* special_function */
123 "R_CKCORE_PCREL_IMM8BY4", /* name */
124 false, /* partial_inplace */
125 0xff, /* src_mask */
126 0xff, /* dst_mask */
127 true), /* pcrel_offset */
128
129 /* 3: Only for csky v1. */
130 HOWTO (R_CKCORE_PCREL_IMM11BY2, /* type */
131 1, /* rightshift */
132 2, /* size */
133 11, /* bitsize */
134 true, /* pc_relative */
135 0, /* bitpos */
136 complain_overflow_signed, /* complain_on_overflow */
137 bfd_elf_generic_reloc, /* special_function */
138 "R_CKCORE_PCREL_IMM11BY2", /* name */
139 false, /* partial_inplace */
140 0x7ff, /* src_mask */
141 0x7ff, /* dst_mask */
142 true), /* pcrel_offset */
143
144 /* 4: DELETED. */
145 HOWTO (R_CKCORE_PCREL_IMM4BY2,0,0,0,0,0,0,0,"R_CKCORE_PCREL_IMM4BY2",0,0,0,0),
146
147 /* 5. */
148 HOWTO (R_CKCORE_PCREL32, /* type */
149 0, /* rightshift */
150 4, /* size */
151 32, /* bitsize */
152 true, /* pc_relative */
153 0, /* bitpos */
154 complain_overflow_dont, /* complain_on_overflow */
155 bfd_elf_generic_reloc, /* special_function */
156 "R_CKCORE_PCREL32", /* name */
157 false, /* partial_inplace */
158 0x0, /* src_mask */
159 0xffffffff, /* dst_mask */
160 true), /* pcrel_offset */
161
162 /* 6: Only for csky v1. */
163 HOWTO (R_CKCORE_PCREL_JSR_IMM11BY2, /* type */
164 1, /* rightshift */
165 2, /* size */
166 11, /* bitsize */
167 true, /* pc_relative */
168 0, /* bitpos */
169 complain_overflow_signed, /* complain_on_overflow */
170 bfd_elf_generic_reloc, /* special_function */
171 "R_CKCORE_PCREL_JSR_IMM11BY2", /* name */
172 false, /* partial_inplace */
173 0x7ff, /* src_mask */
174 0x7ff, /* dst_mask */
175 true), /* pcrel_offset */
176
177 /* 7: GNU extension to record C++ vtable member usage. */
178 HOWTO (R_CKCORE_GNU_VTENTRY, /* type */
179 0, /* rightshift */
180 4, /* size */
181 0, /* bitsize */
182 false, /* pc_relative */
183 0, /* bitpos */
184 complain_overflow_dont, /* complain_on_overflow */
185 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
186 "R_CKCORE_GNU_VTENTRY", /* name */
187 false, /* partial_inplace */
188 0x0, /* src_mask */
189 0x0, /* dst_mask */
190 false), /* pcrel_offset */
191
192 /* 8: GNU extension to record C++ vtable hierarchy. */
193 HOWTO (R_CKCORE_GNU_VTINHERIT, /* type */
194 0, /* rightshift */
195 4, /* size */
196 0, /* bitsize */
197 false, /* pc_relative */
198 0, /* bitpos */
199 complain_overflow_dont, /* complain_on_overflow */
200 NULL, /* special_function */
201 "R_CKCORE_GNU_VTINHERIT", /* name */
202 false, /* partial_inplace */
203 0x0, /* src_mask */
204 0x0, /* dst_mask */
205 false), /* pcrel_offset */
206
207 /* 9. */
208 HOWTO (R_CKCORE_RELATIVE, /* type */
209 0, /* rightshift */
210 4, /* size */
211 32, /* bitsize */
212 false, /* pc_relative */
213 0, /* bitpos */
214 complain_overflow_signed, /* complain_on_overflow */
215 bfd_elf_generic_reloc, /* special_function */
216 "R_CKCORE_RELATIVE", /* name */
217 true, /* partial_inplace */
218 0x0, /* src_mask */
219 0xffffffff, /* dst_mask */
220 false), /* pcrel_offset */
221
222 /* 10: None. */
223 /* FIXME: It is a bug that copy relocations are not implemented. */
224 HOWTO (R_CKCORE_COPY, /* type */
225 0, /* rightshift */
226 4, /* size */
227 32, /* bitsize */
228 false, /* pc_relative */
229 0, /* bitpos */
230 complain_overflow_bitfield, /* complain_on_overflow */
231 bfd_elf_generic_reloc, /* special_function */
232 "R_CKCORE_COPY", /* name */
233 true, /* partial_inplace */
234 0xffffffff, /* src_mask */
235 0xffffffff, /* dst_mask */
236 false), /* pcrel_offset */
237
238 /* 11: None. */
239 HOWTO (R_CKCORE_GLOB_DAT,0,0,0,0,0,0,0,"R_CKCORE_GLOB_DAT",0,0,0,0),
240
241 /* 12: None. */
242 HOWTO (R_CKCORE_JUMP_SLOT,0,0,0,0,0,0,0,"R_CKCORE_JUMP_SLOT",0,0,0,0),
243
244 /* 13. */
245 HOWTO (R_CKCORE_GOTOFF, /* type */
246 0, /* rightshift */
247 4, /* size */
248 32, /* bitsize */
249 false, /* pc_relative */
250 0, /* bitpos */
251 complain_overflow_dont, /* complain_on_overflow */
252 bfd_elf_generic_reloc, /* special_function */
253 "R_CKCORE_GOTOFF", /* name */
254 true, /* partial_inplace */
255 0x0, /* src_mask */
256 0xffffffffl, /* dst_mask */
257 false), /* pcrel_offset */
258
259 /* 14. */
260 HOWTO (R_CKCORE_GOTPC, /* type */
261 0, /* rightshift */
262 4, /* size */
263 32, /* bitsize */
264 true, /* pc_relative */
265 0, /* bitpos */
266 complain_overflow_dont, /* complain_on_overflow */
267 bfd_elf_generic_reloc, /* special_function */
268 "R_CKCORE_GOTPC", /* name */
269 true, /* partial_inplace */
270 0x0, /* src_mask */
271 0xffffffff, /* dst_mask */
272 false), /* pcrel_offset */
273
274 /* 15. */
275 HOWTO (R_CKCORE_GOT32, /* type */
276 0, /* rightshift */
277 4, /* size */
278 32, /* bitsize */
279 false, /* pc_relative */
280 0, /* bitpos */
281 complain_overflow_dont, /* complain_on_overflow */
282 bfd_elf_generic_reloc, /* special_function */
283 "R_CKCORE_GOT32", /* name */
284 true, /* partial_inplace */
285 0x0, /* src_mask */
286 0xffffffff, /* dst_mask */
287 true), /* pcrel_offset */
288
289 /* 16. */
290 HOWTO (R_CKCORE_PLT32, /* type */
291 0, /* rightshift */
292 4, /* size */
293 32, /* bitsize */
294 false, /* pc_relative */
295 0, /* bitpos */
296 complain_overflow_dont, /* complain_on_overflow */
297 bfd_elf_generic_reloc, /* special_function */
298 "R_CKCORE_PLT32", /* name */
299 true, /* partial_inplace */
300 0x0, /* src_mask */
301 0xffffffff, /* dst_mask */
302 true), /* pcrel_offset */
303
304 /* 17: None. */
305 HOWTO (R_CKCORE_ADDRGOT,0,0,0,0,0,0,0,"R_CKCORE_ADDRGOT",0,0,0,0),
306
307 /* 18: None. */
308 HOWTO (R_CKCORE_ADDRPLT,0,0,0,0,0,0,0,"R_CKCORE_ADDRPLT",0,0,0,0),
309
310 /* 19: Only for csky v2. */
311 HOWTO (R_CKCORE_PCREL_IMM26BY2, /* type */
312 1, /* rightshift */
313 4, /* size */
314 26, /* bitsize */
315 true, /* pc_relative */
316 0, /* bitpos */
317 complain_overflow_signed, /* complain_on_overflow */
318 bfd_elf_generic_reloc, /* special_function */
319 "R_CKCORE_PCREL_IMM26BY2", /* name */
320 false, /* partial_inplace */
321 0x0, /* src_mask */
322 0x3ffffff, /* dst_mask */
323 true), /* pcrel_offset */
324
325 /* 20: Only for csky v2. */
326 HOWTO (R_CKCORE_PCREL_IMM16BY2, /* type */
327 1, /* rightshift */
328 4, /* size */
329 16, /* bitsize */
330 true, /* pc_relative */
331 0, /* bitpos */
332 complain_overflow_signed, /* complain_on_overflow */
333 bfd_elf_generic_reloc, /* special_function */
334 "R_CKCORE_PCREL_IMM16BY2", /* name */
335 false, /* partial_inplace */
336 0x0, /* src_mask */
337 0xffff, /* dst_mask */
338 true), /* pcrel_offset */
339
340 /* 21: Only for csky v2. */
341 HOWTO (R_CKCORE_PCREL_IMM16BY4, /* type */
342 2, /* rightshift */
343 4, /* size */
344 16, /* bitsize */
345 true, /* pc_relative */
346 0, /* bitpos */
347 complain_overflow_bitfield, /* complain_on_overflow */
348 bfd_elf_generic_reloc, /* special_function */
349 "R_CKCORE_PCREL_IMM16BY4", /* name */
350 false, /* partial_inplace */
351 0xffff0000, /* src_mask */
352 0xffff, /* dst_mask */
353 true), /* pcrel_offset */
354
355 /* 22: Only for csky v2. */
356 HOWTO (R_CKCORE_PCREL_IMM10BY2, /* type */
357 1, /* rightshift */
358 2, /* size */
359 10, /* bitsize */
360 true, /* pc_relative */
361 0, /* bitpos */
362 complain_overflow_signed, /* complain_on_overflow */
363 bfd_elf_generic_reloc, /* special_function */
364 "R_CKCORE_PCREL_IMM10BY2", /* name */
365 false, /* partial_inplace */
366 0x0, /* src_mask */
367 0x3ff, /* dst_mask */
368 true), /* pcrel_offset */
369
370 /* 23: Only for csky v2. */
371 HOWTO (R_CKCORE_PCREL_IMM10BY4, /* type */
372 2, /* rightshift */
373 4, /* size */
374 10, /* bitsize */
375 true, /* pc_relative */
376 0, /* bitpos */
377 complain_overflow_bitfield, /* complain_on_overflow */
378 bfd_elf_generic_reloc, /* special_function */
379 "R_CKCORE_PCREL_IMM10BY4", /* name */
380 false, /* partial_inplace */
381 0x0, /* src_mask */
382 0x3ff, /* dst_mask */
383 true), /* pcrel_offset */
384
385 /* 24: Only for csky v2. */
386 HOWTO (R_CKCORE_ADDR_HI16, /* type */
387 16, /* rightshift */
388 4, /* size */
389 16, /* bitsize */
390 false, /* pc_relative */
391 0, /* bitpos */
392 complain_overflow_dont, /* complain_on_overflow */
393 bfd_elf_generic_reloc, /* special_function */
394 "R_CKCORE_ADDR_HI16", /* name */
395 false, /* partial_inplace */
396 0x0, /* src_mask */
397 0xffff, /* dst_mask */
398 false), /* pcrel_offset */
399
400 /* 25. */
401 HOWTO (R_CKCORE_ADDR_LO16, /* type */
402 0, /* rightshift */
403 4, /* size */
404 16, /* bitsize */
405 false, /* pc_relative */
406 0, /* bitpos */
407 complain_overflow_dont, /* complain_on_overflow */
408 bfd_elf_generic_reloc, /* special_function */
409 "R_CKCORE_ADDR_LO16", /* name */
410 false, /* partial_inplace */
411 0x0, /* src_mask */
412 0xffff, /* dst_mask */
413 false), /* pcrel_offset */
414
415 /* 26. */
416 HOWTO (R_CKCORE_GOTPC_HI16, /* type */
417 16, /* rightshift */
418 4, /* size */
419 16, /* bitsize */
420 true, /* pc_relative */
421 0, /* bitpos */
422 complain_overflow_dont, /* complain_on_overflow */
423 bfd_elf_generic_reloc, /* special_function */
424 "R_CKCORE_GOTPC_HI16", /* name */
425 false, /* partial_inplace */
426 0x0, /* src_mask */
427 0xffff, /* dst_mask */
428 false), /* pcrel_offset */
429
430 /* 27. */
431 HOWTO (R_CKCORE_GOTPC_LO16, /* type */
432 0, /* rightshift */
433 4, /* size */
434 16, /* bitsize */
435 true, /* pc_relative */
436 0, /* bitpos */
437 complain_overflow_dont, /* complain_on_overflow */
438 bfd_elf_generic_reloc, /* special_function */
439 "R_CKCORE_GOTPC_LO16", /* name */
440 false, /* partial_inplace */
441 0x0, /* src_mask */
442 0xffff, /* dst_mask */
443 false), /* pcrel_offset */
444
445 /* 28. */
446 HOWTO (R_CKCORE_GOTOFF_HI16, /* type */
447 16, /* rightshift */
448 4, /* size */
449 16, /* bitsize */
450 false, /* pc_relative */
451 0, /* bitpos */
452 complain_overflow_dont, /* complain_on_overflow */
453 bfd_elf_generic_reloc, /* special_function */
454 "R_CKCORE_GOTOFF_HI16", /* name */
455 false, /* partial_inplace */
456 0x0, /* src_mask */
457 0xffff, /* dst_mask */
458 false), /* pcrel_offset */
459
460 /* 29. */
461 HOWTO (R_CKCORE_GOTOFF_LO16, /* type */
462 0, /* rightshift */
463 4, /* size */
464 16, /* bitsize */
465 false, /* pc_relative */
466 0, /* bitpos */
467 complain_overflow_dont, /* complain_on_overflow */
468 bfd_elf_generic_reloc, /* special_function */
469 "R_CKCORE_GOTOFF_LO16", /* name */
470 false, /* partial_inplace */
471 0x0, /* src_mask */
472 0xffff, /* dst_mask */
473 false), /* pcrel_offset */
474
475 /* 30. */
476 HOWTO (R_CKCORE_GOT12, /* type */
477 2, /* rightshift */
478 4, /* size */
479 12, /* bitsize */
480 false, /* pc_relative */
481 0, /* bitpos */
482 complain_overflow_bitfield, /* complain_on_overflow */
483 bfd_elf_generic_reloc, /* special_function */
484 "R_CKCORE_GOT12", /* name */
485 true, /* partial_inplace */
486 0x0, /* src_mask */
487 0xfff, /* dst_mask */
488 false), /* pcrel_offset */
489
490 /* 31. */
491 HOWTO (R_CKCORE_GOT_HI16, /* type */
492 16, /* rightshift */
493 4, /* size */
494 16, /* bitsize */
495 false, /* pc_relative */
496 0, /* bitpos */
497 complain_overflow_dont, /* complain_on_overflow */
498 bfd_elf_generic_reloc, /* special_function */
499 "R_CKCORE_GOT_HI16", /* name */
500 true, /* partial_inplace */
501 0x0, /* src_mask */
502 0xffff, /* dst_mask */
503 false), /* pcrel_offset */
504
505 /* 32. */
506 HOWTO (R_CKCORE_GOT_LO16, /* type */
507 0, /* rightshift */
508 4, /* size */
509 16, /* bitsize */
510 false, /* pc_relative */
511 0, /* bitpos */
512 complain_overflow_dont, /* complain_on_overflow */
513 bfd_elf_generic_reloc, /* special_function */
514 "R_CKCORE_GOT_LO16", /* name */
515 true, /* partial_inplace */
516 0x0, /* src_mask */
517 0xffff, /* dst_mask */
518 false), /* pcrel_offset */
519
520 /* 33. */
521 HOWTO (R_CKCORE_PLT12, /* type */
522 2, /* rightshift */
523 4, /* size */
524 12, /* bitsize */
525 false, /* pc_relative */
526 0, /* bitpos */
527 complain_overflow_bitfield, /* complain_on_overflow */
528 bfd_elf_generic_reloc, /* special_function */
529 "R_CKCORE_PLT12", /* name */
530 true, /* partial_inplace */
531 0x0, /* src_mask */
532 0xfff, /* dst_mask */
533 false), /* pcrel_offset */
534
535 /* 34. */
536 HOWTO (R_CKCORE_PLT_HI16, /* type */
537 16, /* rightshift */
538 4, /* size */
539 16, /* bitsize */
540 false, /* pc_relative */
541 0, /* bitpos */
542 complain_overflow_dont, /* complain_on_overflow */
543 bfd_elf_generic_reloc, /* special_function */
544 "R_CKCORE_PLT_HI16", /* name */
545 true, /* partial_inplace */
546 0x0, /* src_mask */
547 0xffff, /* dst_mask */
548 false), /* pcrel_offset */
549
550 /* 35. */
551 HOWTO (R_CKCORE_PLT_LO16, /* type */
552 0, /* rightshift */
553 4, /* size */
554 16, /* bitsize */
555 false, /* pc_relative */
556 0, /* bitpos */
557 complain_overflow_dont, /* complain_on_overflow */
558 bfd_elf_generic_reloc, /* special_function */
559 "R_CKCORE_PLT_LO16", /* name */
560 true, /* partial_inplace */
561 0x0, /* src_mask */
562 0xffff, /* dst_mask */
563 false), /* pcrel_offset */
564
565 /* 36: None. */
566 HOWTO (R_CKCORE_ADDRGOT_HI16,0,0,0,0,0,0,0,"R_CKCORE_",0,0,0,0),
567
568 /* 37: None. */
569 HOWTO (R_CKCORE_ADDRGOT_LO16,0,0,0,0,0,0,0,"R_CKCORE_",0,0,0,0),
570
571 /* 38: None. */
572 HOWTO (R_CKCORE_ADDRPLT_HI16,0,0,0,0,0,0,0,"R_CKCORE_",0,0,0,0),
573
574 /* 39: None. */
575 HOWTO (R_CKCORE_ADDRPLT_LO16,0,0,0,0,0,0,0,"R_CKCORE_",0,0,0,0),
576
577 /* 40. */
578 HOWTO (R_CKCORE_PCREL_JSR_IMM26BY2, /* type */
579 1, /* rightshift */
580 4, /* size */
581 26, /* bitsize */
582 true, /* pc_relative */
583 0, /* bitpos */
584 complain_overflow_signed, /* complain_on_overflow */
585 bfd_elf_generic_reloc, /* special_function */
586 "R_CKCORE_PCREL_JSR_IMM26BY2", /* name */
587 false, /* partial_inplace */
588 0x0, /* src_mask */
589 0x3ffffff, /* dst_mask */
590 true), /* pcrel_offset */
591
592 /* 41. */
593 HOWTO (R_CKCORE_TOFFSET_LO16, /* type */
594 0, /* rightshift */
595 4, /* size */
596 16, /* bitsize */
597 false, /* pc_relative */
598 0, /* bitpos */
599 complain_overflow_unsigned, /* complain_on_overflow */
600 NULL, /* special_function */
601 "R_CKCORE_TOFFSET_LO16", /* name */
602 false, /* partial_inplace */
603 0x0, /* src_mask */
604 0xffff, /* dst_mask */
605 false), /* pcrel_offset */
606
607 /* 42. */
608 HOWTO (R_CKCORE_DOFFSET_LO16, /* type */
609 0, /* rightshift */
610 4, /* size */
611 16, /* bitsize */
612 false, /* pc_relative */
613 0, /* bitpos */
614 complain_overflow_unsigned, /* complain_on_overflow */
615 NULL, /* special_function */
616 "R_CKCORE_DOFFSET_LO16", /* name */
617 false, /* partial_inplace */
618 0x0, /* src_mask */
619 0xffff, /* dst_mask */
620 false), /* pcrel_offset */
621
622 /* 43. */
623 HOWTO (R_CKCORE_PCREL_IMM18BY2, /* type */
624 1, /* rightshift */
625 4, /* size */
626 18, /* bitsize */
627 true, /* pc_relative */
628 0, /* bitpos */
629 complain_overflow_signed, /* complain_on_overflow */
630 bfd_elf_generic_reloc, /* special_function */
631 "R_CKCORE_PCREL_IMM18BY2", /* name */
632 false, /* partial_inplace */
633 0x0, /* src_mask */
634 0x3ffff, /* dst_mask */
635 true), /* pcrel_offset */
636
637 /* 44. */
638 HOWTO (R_CKCORE_DOFFSET_IMM18, /* type */
639 0, /* rightshift */
640 4, /* size */
641 18, /* bitsize */
642 false, /* pc_relative */
643 0, /* bitpos */
644 complain_overflow_unsigned, /* complain_on_overflow */
645 NULL, /* special_function */
646 "R_CKCORE_DOFFSET_IMM18", /* name */
647 false, /* partial_inplace */
648 0x0, /* src_mask */
649 0x3ffff, /* dst_mask */
650 false), /* pcrel_offset */
651
652 /* 45. */
653 HOWTO (R_CKCORE_DOFFSET_IMM18BY2, /* type */
654 1, /* rightshift */
655 4, /* size */
656 18, /* bitsize */
657 false, /* pc_relative */
658 0, /* bitpos */
659 complain_overflow_unsigned, /* complain_on_overflow */
660 NULL, /* special_function */
661 "R_CKCORE_DOFFSET_IMM18BY2", /* name */
662 false, /* partial_inplace */
663 0x0, /* src_mask */
664 0x3ffff, /* dst_mask */
665 false), /* pcrel_offset */
666
667 /* 46. */
668 HOWTO (R_CKCORE_DOFFSET_IMM18BY4, /* type */
669 2, /* rightshift */
670 4, /* size */
671 18, /* bitsize */
672 false, /* pc_relative */
673 0, /* bitpos */
674 complain_overflow_unsigned, /* complain_on_overflow */
675 NULL, /* special_function */
676 "R_CKCORE_DOFFSET_IMM18BY4", /* name */
677 false, /* partial_inplace */
678 0x0, /* src_mask */
679 0x3ffff, /* dst_mask */
680 false), /* pcrel_offset */
681
682 /* 47. */
683 HOWTO (R_CKCORE_GOTOFF_IMM18, /* type */
684 0, /* rightshift */
685 4, /* size */
686 18, /* bitsize */
687 false, /* pc_relative */
688 0, /* bitpos */
689 complain_overflow_bitfield, /* complain_on_overflow */
690 bfd_elf_generic_reloc, /* special_function */
691 "R_CKCORE_GOTOFF_IMM18", /* name */
692 true, /* partial_inplace */
693 0xfffc, /* src_mask */
694 0x3ffff, /* dst_mask */
695 false), /* pcrel_offset */
696
697 /* 48. */
698 HOWTO (R_CKCORE_GOT_IMM18BY4, /* type */
699 2, /* rightshift */
700 4, /* size */
701 18, /* bitsize */
702 false, /* pc_relative */
703 0, /* bitpos */
704 complain_overflow_bitfield, /* complain_on_overflow */
705 bfd_elf_generic_reloc, /* special_function */
706 "R_CKCORE_GOT_IMM18BY4", /* name */
707 true, /* partial_inplace */
708 0xfffc, /* src_mask */
709 0x3ffff, /* dst_mask */
710 false), /* pcrel_offset */
711
712 /* 49. */
713 HOWTO (R_CKCORE_PLT_IMM18BY4, /* type */
714 2, /* rightshift */
715 4, /* size */
716 18, /* bitsize */
717 false, /* pc_relative */
718 0, /* bitpos */
719 complain_overflow_bitfield, /* complain_on_overflow */
720 bfd_elf_generic_reloc, /* special_function */
721 "R_CKCORE_PLT_IMM18BY4", /* name */
722 true, /* partial_inplace */
723 0xfffc, /* src_mask */
724 0x3ffff, /* dst_mask */
725 true), /* pcrel_offset */
726
727 /* 50: for lrw16. */
728 HOWTO (R_CKCORE_PCREL_IMM7BY4, /* type */
729 2, /* rightshift */
730 2, /* size */
731 7, /* bitsize */
732 true, /* pc_relative */
733 0, /* bitpos */
734 complain_overflow_bitfield, /* complain_on_overflow */
735 bfd_elf_generic_reloc, /* special_function */
736 "R_CKCORE_PCREL_IMM7BY4", /* name */
737 false, /* partial_inplace */
738 0xec1f, /* src_mask */
739 0x31f, /* dst_mask */
740 true), /* pcrel_offset */
741
742 /* 51: for static nptl. */
743 HOWTO (R_CKCORE_TLS_LE32, /* type */
744 0, /* rightshift */
745 4, /* size */
746 32, /* bitsize */
747 false, /* pc_relative */
748 0, /* bitpos */
749 complain_overflow_dont, /* complain_on_overflow */
750 bfd_elf_generic_reloc, /* special_function */
751 "R_CKCORE_TLS_LE32", /* name */
752 false, /* partial_inplace */
753 0x0, /* src_mask */
754 0xffffffff, /* dst_mask */
755 true), /* pcrel_offset */
756
757 /* 52: for static nptl. */
758 HOWTO (R_CKCORE_TLS_IE32, /* type */
759 0, /* rightshift */
760 4, /* size */
761 32, /* bitsize */
762 false, /* pc_relative */
763 0, /* bitpos */
764 complain_overflow_dont, /* complain_on_overflow */
765 bfd_elf_generic_reloc, /* special_function */
766 "R_CKCORE_TLS_IE32", /* name */
767 false, /* partial_inplace */
768 0x0, /* src_mask */
769 0xffffffff, /* dst_mask */
770 true), /* pcrel_offset */
771
772 /* 53: for pic nptl. */
773 HOWTO (R_CKCORE_TLS_GD32, /* type */
774 0, /* rightshift */
775 4, /* size */
776 32, /* bitsize */
777 false, /* pc_relative */
778 0, /* bitpos */
779 complain_overflow_dont, /* complain_on_overflow */
780 bfd_elf_generic_reloc, /* special_function */
781 "R_CKCORE_TLS_GD32", /* name */
782 false, /* partial_inplace */
783 0x0, /* src_mask */
784 0xffffffff, /* dst_mask */
785 true), /* pcrel_offset */
786
787 /* 54: for pic nptl. */
788 HOWTO (R_CKCORE_TLS_LDM32, /* type */
789 0, /* rightshift */
790 4, /* size */
791 32, /* bitsize */
792 false, /* pc_relative */
793 0, /* bitpos */
794 complain_overflow_dont, /* complain_on_overflow */
795 bfd_elf_generic_reloc, /* special_function */
796 "R_CKCORE_TLS_LDM32", /* name */
797 false, /* partial_inplace */
798 0x0, /* src_mask */
799 0xffffffff, /* dst_mask */
800 true), /* pcrel_offset */
801
802 /* 55: for pic nptl. */
803 HOWTO (R_CKCORE_TLS_LDO32, /* type */
804 0, /* rightshift */
805 4, /* size */
806 32, /* bitsize */
807 false, /* pc_relative */
808 0, /* bitpos */
809 complain_overflow_dont, /* complain_on_overflow */
810 bfd_elf_generic_reloc, /* special_function */
811 "R_CKCORE_TLS_LDO32", /* name */
812 false, /* partial_inplace */
813 0x0, /* src_mask */
814 0xffffffff, /* dst_mask */
815 true), /* pcrel_offset */
816
817 /* 56: for linker. */
818 HOWTO (R_CKCORE_TLS_DTPMOD32,0,0,0,0,0,0,0,"R_CKCORE_TLS_DTPMOD32",0,0,0,0),
819
820 /* 57: for linker. */
821 HOWTO (R_CKCORE_TLS_DTPOFF32,0,0,0,0,0,0,0,"R_CKCORE_TLS_DTPOFF32",0,0,0,0),
822
823 /* 58: for linker. */
824 HOWTO (R_CKCORE_TLS_TPOFF32,0,0,0,0,0,0,0,"R_CKCORE_TLS_TPOFF32",0,0,0,0),
825
826 /* 59: for ck807f. */
827 HOWTO (R_CKCORE_PCREL_FLRW_IMM8BY4, /* type */
828 2, /* rightshift */
829 4, /* size */
830 8, /* bitsize */
831 true, /* pc_relative */
832 0, /* bitpos */
833 complain_overflow_bitfield, /* complain_on_overflow */
834 bfd_elf_generic_reloc, /* special_function */
835 "R_CKCORE_PCREL_FLRW_IMM8BY4",/* name */
836 false, /* partial_inplace */
837 0xfe1fff0f, /* src_mask */
838 0x1e000f0, /* dst_mask */
839 true), /* pcrel_offset */
840
841 /* 60: for 810 not to generate jsri. */
842 HOWTO (R_CKCORE_NOJSRI, /* type */
843 0, /* rightshift */
844 4, /* size */
845 32, /* bitsize */
846 false, /* pc_relative */
847 0, /* bitpos */
848 complain_overflow_dont, /* complain_on_overflow */
849 bfd_elf_generic_reloc, /* special_function */
850 "R_CKCORE_NOJSRI", /* name */
851 false, /* partial_inplace */
852 0xffff, /* src_mask */
853 0xffff, /* dst_mask */
854 false), /* pcrel_offset */
855
856 /* 61: for callgraph. */
857 HOWTO (R_CKCORE_CALLGRAPH, /* type */
858 0, /* rightshift */
859 0, /* size */
860 0, /* bitsize */
861 false, /* pc_relative */
862 0, /* bitpos */
863 complain_overflow_dont, /* complain_on_overflow */
864 NULL, /* special_function */
865 "R_CKCORE_CALLGRAPH", /* name */
866 false, /* partial_inplace */
867 0x0, /* src_mask */
868 0x0, /* dst_mask */
869 true), /* pcrel_offset */
870
871 /* 62: IRELATIVE*/
872 HOWTO (R_CKCORE_IRELATIVE,0,0,0,0,0,0,0,"R_CKCORE_IRELATIVE",0,0,0,0),
873
874 /* 63: for bloop instruction */
875 HOWTO (R_CKCORE_PCREL_BLOOP_IMM4BY4, /* type */
876 1, /* rightshift */
877 4, /* size */
878 4, /* bitsize */
879 1, /* pc_relative */
880 0, /* bitpos */
881 complain_overflow_signed, /* complain_on_overflow */
882 bfd_elf_generic_reloc, /* special_function */
883 "R_CKCORE_PCREL_BLOOP_IMM4BY4", /* name */
884 false, /* partial_inplace */
885 0x0, /* src_mask */
886 0xf, /* dst_mask */
887 true), /* pcrel_offset */
888 /* 64: for bloop instruction */
889 HOWTO (R_CKCORE_PCREL_BLOOP_IMM12BY4, /* type */
890 1, /* rightshift */
891 4, /* size */
892 12, /* bitsize */
893 1, /* pc_relative */
894 0, /* bitpos */
895 complain_overflow_signed, /* complain_on_overflow */
896 bfd_elf_generic_reloc, /* special_function */
897 "R_CKCORE_PCREL_BLOOP_IMM12BY4", /* name */
898 false, /* partial_inplace */
899 0x0, /* src_mask */
900 0xfff, /* dst_mask */
901 true), /* pcrel_offset */
902
903
904 };
905
906
907 /* Whether GOT overflow checking is needed. */
908 static int check_got_overflow = 0;
909
910 /* Whether the target 32 bits is forced so that the high
911 16 bits is at the low address. */
912 static int need_reverse_bits;
913
914 /* Used for relaxation. See csky_relocate_contents. */
915 static bfd_vma read_content_substitute;
916
917 /* NOTICE!
918 The way the following two look-up functions work demands
919 that BFD_RELOC_CKCORE_xxx are defined contiguously. */
920
921 static reloc_howto_type *
922 csky_elf_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
923 bfd_reloc_code_real_type code)
924 {
925 int csky_code = code - BFD_RELOC_CKCORE_NONE;
926
927 if (csky_code < 0 || csky_code >= R_CKCORE_MAX)
928 {
929 switch (code)
930 {
931 case BFD_RELOC_NONE:
932 csky_code = R_CKCORE_NONE;
933 break;
934 case BFD_RELOC_32:
935 csky_code = R_CKCORE_ADDR32;
936 break;
937 case BFD_RELOC_32_PCREL:
938 csky_code = R_CKCORE_PCREL32;
939 break;
940 case BFD_RELOC_VTABLE_INHERIT:
941 csky_code = R_CKCORE_GNU_VTINHERIT;
942 break;
943 case BFD_RELOC_VTABLE_ENTRY:
944 csky_code = R_CKCORE_GNU_VTENTRY;
945 break;
946 case BFD_RELOC_RVA:
947 csky_code = R_CKCORE_RELATIVE;
948 break;
949 default:
950 return (reloc_howto_type *)NULL;
951 }
952 }
953 /* Note: when adding csky bfd reloc types in bfd-in2.h
954 and csky elf reloc types in elf/csky.h,
955 the order of the two reloc type tables should be consistent. */
956 return &csky_elf_howto_table[csky_code];
957 }
958
959 static reloc_howto_type *
960 csky_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
961 const char *r_name)
962 {
963 unsigned int i;
964 for (i = 0; i < R_CKCORE_MAX; i++)
965 if (strcasecmp (csky_elf_howto_table[i].name, r_name) == 0)
966 return &csky_elf_howto_table[i];
967 return NULL;
968 }
969
970 static reloc_howto_type *
971 elf32_csky_howto_from_type (unsigned int r_type)
972 {
973 if (r_type < R_CKCORE_MAX)
974 return &csky_elf_howto_table[r_type];
975 else
976 return NULL;
977 }
978
979 static bool
980 csky_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
981 arelent *cache_ptr,
982 Elf_Internal_Rela *dst)
983 {
984 unsigned int r_type;
985
986 r_type = ELF32_R_TYPE (dst->r_info);
987 cache_ptr->howto = elf32_csky_howto_from_type (r_type);
988 if (cache_ptr->howto == NULL)
989 {
990 /* xgettext:c-format */
991 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
992 abfd, r_type);
993 bfd_set_error (bfd_error_bad_value);
994 return false;
995 }
996 return true;
997 }
998
999 /* The Global Offset Table max size. */
1000 #define GOT_MAX_SIZE 0xFFFF8
1001
1002 /* The name of the dynamic interpreter. This is put in the .interp
1003 section. */
1004 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
1005
1006 /* The size in bytes of an entry in the procedure linkage table. */
1007 #define PLT_ENTRY_SIZE 12
1008 #define PLT_ENTRY_SIZE_P 16
1009
1010 /* The first entry in a procedure linkage table looks like
1011 this. It is set up so that any shared library function that is
1012 called before the relocation has been set up calls the dynamic
1013 linker first. */
1014 static const bfd_vma csky_elf_plt_entry_v2[PLT_ENTRY_SIZE / 4] =
1015 {
1016 0xd99c2002, /* ldw r12, (gb, 8) */
1017 0xea0d0000, /* movi r13,offset */
1018 0xe8cc0000 /* jmp r12 */
1019 };
1020
1021 static const bfd_vma csky_elf_plt_entry_v1[PLT_ENTRY_SIZE / 2 ] =
1022 {
1023 0x25f0, /* subi r0, 32 */
1024 0x9200, /* stw r2, (r0, 0) */
1025 0x9310, /* stw r3, (r0, 4) */
1026 0x822e, /* ldw r2, (gb, 8) */
1027 0x7301, /* lrw r3, #offset */
1028 0x00c2, /* jmp r2 */
1029 };
1030
1031 /* Branch stub support. */
1032
1033 enum stub_insn_type
1034 {
1035 INSN16,
1036 INSN32,
1037 DATA_TYPE
1038 };
1039
1040 bool use_branch_stub = true;
1041 typedef struct
1042 {
1043 bfd_vma data;
1044 enum stub_insn_type type;
1045 unsigned int r_type;
1046 int reloc_addend;
1047 } insn_sequence;
1048
1049 static const insn_sequence elf32_csky_stub_long_branch[] =
1050 {
1051 {0xea8d0002, INSN32, R_CKCORE_NONE, 0x0}, /* lrw t1,[pc+8] */
1052 {0x7834, INSN16, R_CKCORE_NONE, 0x0}, /* jmp t1 */
1053 {0x6c03, INSN16, R_CKCORE_NONE, 0x0}, /* nop */
1054 {0x0, DATA_TYPE, R_CKCORE_ADDR32, 0x0} /* .long addr */
1055 };
1056
1057 static const insn_sequence elf32_csky_stub_long_branch_jmpi[] =
1058 {
1059 {0xeac00001, INSN32, R_CKCORE_NONE, 0x0}, /* jmpi [pc+4] */
1060 {0x0, DATA_TYPE, R_CKCORE_ADDR32, 0x0} /* .long addr */
1061 };
1062
1063 /* The bsr instruction offset limit. */
1064 #define BSR_MAX_FWD_BRANCH_OFFSET (((1 << 25) - 1) << 1)
1065 #define BSR_MAX_BWD_BRANCH_OFFSET (-(1 << 26))
1066
1067 #define STUB_SUFFIX ".stub"
1068 #define STUB_ENTRY_NAME "__%s_veneer"
1069
1070 /* One entry per long/short branch stub defined above. */
1071 #define DEF_STUBS \
1072 DEF_STUB(long_branch) \
1073 DEF_STUB(long_branch_jmpi)
1074
1075 #define DEF_STUB(x) csky_stub_##x,
1076 enum elf32_csky_stub_type
1077 {
1078 csky_stub_none,
1079 DEF_STUBS
1080 };
1081 #undef DEF_STUB
1082
1083 typedef struct
1084 {
1085 const insn_sequence* template_sequence;
1086 int template_size;
1087 } stub_def;
1088
1089 #define DEF_STUB(x) {elf32_csky_stub_##x, ARRAY_SIZE(elf32_csky_stub_##x)},
1090 static const stub_def stub_definitions[] = {
1091 {NULL, 0},
1092 DEF_STUBS
1093 };
1094
1095 /* The size of the thread control block. */
1096 #define TCB_SIZE 8
1097
1098 struct csky_elf_obj_tdata
1099 {
1100 struct elf_obj_tdata root;
1101
1102 /* tls_type for each local got entry. */
1103 char *local_got_tls_type;
1104 };
1105
1106 #define csky_elf_local_got_tls_type(bfd) \
1107 (csky_elf_tdata (bfd)->local_got_tls_type)
1108
1109 #define csky_elf_tdata(bfd) \
1110 ((struct csky_elf_obj_tdata *) (bfd)->tdata.any)
1111
1112 struct elf32_csky_stub_hash_entry
1113 {
1114 /* Base hash table entry structure. */
1115 struct bfd_hash_entry root;
1116
1117 /* The stub section. */
1118 asection *stub_sec;
1119
1120 /* Offset within stub_sec of the beginning of this stub. */
1121 bfd_vma stub_offset;
1122
1123 /* Given the symbol's value and its section we can determine its final
1124 value when building the stubs (so the stub knows where to jump). */
1125 bfd_vma target_value;
1126 asection *target_section;
1127
1128 /* Offset to apply to relocation referencing target_value. */
1129 bfd_vma target_addend;
1130
1131 /* The stub type. */
1132 enum elf32_csky_stub_type stub_type;
1133 /* Its encoding size in bytes. */
1134 int stub_size;
1135 /* Its template. */
1136 const insn_sequence *stub_template;
1137 /* The size of the template (number of entries). */
1138 int stub_template_size;
1139
1140 /* The symbol table entry, if any, that this was derived from. */
1141 struct csky_elf_link_hash_entry *h;
1142
1143 /* Destination symbol type. */
1144 unsigned char st_type;
1145
1146 /* Where this stub is being called from, or, in the case of combined
1147 stub sections, the first input section in the group. */
1148 asection *id_sec;
1149
1150 /* The name for the local symbol at the start of this stub. The
1151 stub name in the hash table has to be unique; this does not, so
1152 it can be friendlier. */
1153 char *output_name;
1154 };
1155
1156 #define csky_stub_hash_lookup(table, string, create, copy) \
1157 ((struct elf32_csky_stub_hash_entry *) \
1158 bfd_hash_lookup ((table), (string), (create), (copy)))
1159
1160 /* C-SKY ELF linker hash entry. */
1161 struct csky_elf_link_hash_entry
1162 {
1163 struct elf_link_hash_entry elf;
1164 int plt_refcount;
1165 /* For sub jsri2bsr relocs count. */
1166 int jsri2bsr_refcount;
1167
1168 #define GOT_UNKNOWN 0
1169 #define GOT_NORMAL 1
1170 #define GOT_TLS_GD 2
1171 #define GOT_TLS_IE 4
1172
1173 unsigned char tls_type;
1174
1175 /* A pointer to the most recently used stub hash entry against this
1176 symbol. */
1177 struct elf32_csky_stub_hash_entry *stub_cache;
1178 };
1179
1180 /* Traverse an C-SKY ELF linker hash table. */
1181 #define csky_elf_link_hash_traverse(table, func, info) \
1182 (elf_link_hash_traverse \
1183 (&(table)->root, \
1184 (bool (*) (struct elf_link_hash_entry *, void *)) (func), \
1185 (info)))
1186
1187 /* Get the C-SKY ELF linker hash table from a link_info structure. */
1188 #define csky_elf_hash_table(p) \
1189 ((is_elf_hash_table ((p)->hash) \
1190 && elf_hash_table_id (elf_hash_table (p)) == CSKY_ELF_DATA) \
1191 ? (struct csky_elf_link_hash_table *) (p)->hash : NULL)
1192
1193 #define csky_elf_hash_entry(ent) ((struct csky_elf_link_hash_entry*)(ent))
1194
1195 /* Array to keep track of which stub sections have been created, and
1196 information on stub grouping. */
1197 struct map_stub
1198 {
1199 /* This is the section to which stubs in the group will be
1200 attached. */
1201 asection *link_sec;
1202 /* The stub section. */
1203 asection *stub_sec;
1204 };
1205
1206 /* C-SKY ELF linker hash table. */
1207 struct csky_elf_link_hash_table
1208 {
1209 struct elf_link_hash_table elf;
1210
1211 /* Data for R_CKCORE_TLS_LDM32 relocations. */
1212 union
1213 {
1214 bfd_signed_vma refcount;
1215 bfd_vma offset;
1216 } tls_ldm_got;
1217
1218 /* The stub hash table. */
1219 struct bfd_hash_table stub_hash_table;
1220
1221 /* Linker stub bfd. */
1222 bfd *stub_bfd;
1223
1224 /* Linker call-backs. */
1225 asection * (*add_stub_section) (const char *, asection *);
1226 void (*layout_sections_again) (void);
1227
1228 /* Array to keep track of which stub sections have been created, and
1229 * information on stub grouping. */
1230 struct map_stub *stub_group;
1231
1232 /* Number of elements in stub_group. */
1233 unsigned int top_id;
1234
1235 /* Assorted information used by elf32_csky_size_stubs. */
1236 unsigned int bfd_count;
1237 unsigned int top_index;
1238 asection **input_list;
1239 };
1240
1241 /* We can't change vectors in the bfd target which will apply to
1242 data sections, however we only do this to the text sections. */
1243
1244 static bfd_vma
1245 csky_get_insn_32 (bfd *input_bfd,
1246 bfd_byte *location)
1247 {
1248 if (bfd_big_endian (input_bfd))
1249 return bfd_get_32 (input_bfd, location);
1250 else
1251 return (bfd_get_16 (input_bfd, location) << 16
1252 | bfd_get_16 (input_bfd, location + 2));
1253 }
1254
1255 static void
1256 csky_put_insn_32 (bfd *input_bfd,
1257 bfd_vma x,
1258 bfd_byte *location)
1259 {
1260 if (bfd_big_endian (input_bfd))
1261 bfd_put_32 (input_bfd, x, location);
1262 else
1263 {
1264 bfd_put_16 (input_bfd, x >> 16, location);
1265 bfd_put_16 (input_bfd, x & 0xffff, location + 2);
1266 }
1267 }
1268
1269 /* Find or create a stub section. Returns a pointer to the stub section, and
1270 the section to which the stub section will be attached (in *LINK_SEC_P).
1271 LINK_SEC_P may be NULL. */
1272
1273 static asection *
1274 elf32_csky_create_or_find_stub_sec (asection **link_sec_p, asection *section,
1275 struct csky_elf_link_hash_table *htab)
1276 {
1277 asection *link_sec;
1278 asection *stub_sec;
1279
1280 link_sec = htab->stub_group[section->id].link_sec;
1281 stub_sec = htab->stub_group[section->id].stub_sec;
1282 if (stub_sec == NULL)
1283 {
1284 stub_sec = htab->stub_group[link_sec->id].stub_sec;
1285 if (stub_sec == NULL)
1286 {
1287 size_t namelen;
1288 bfd_size_type len;
1289 char *s_name;
1290
1291 namelen = strlen (link_sec->name);
1292 len = namelen + sizeof (STUB_SUFFIX);
1293 s_name = bfd_alloc (htab->stub_bfd, len);
1294 if (s_name == NULL)
1295 return NULL;
1296
1297 memcpy (s_name, link_sec->name, namelen);
1298 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
1299 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
1300 if (stub_sec == NULL)
1301 return NULL;
1302 htab->stub_group[link_sec->id].stub_sec = stub_sec;
1303 }
1304 htab->stub_group[section->id].stub_sec = stub_sec;
1305 }
1306
1307 if (link_sec_p)
1308 *link_sec_p = link_sec;
1309
1310 return stub_sec;
1311 }
1312
1313 /* Build a name for an entry in the stub hash table. */
1314
1315 static char *
1316 elf32_csky_stub_name (const asection *input_section,
1317 const asection *sym_sec,
1318 const struct csky_elf_link_hash_entry *hash,
1319 const Elf_Internal_Rela *rel)
1320 {
1321 char *stub_name;
1322 bfd_size_type len;
1323
1324 if (hash)
1325 {
1326 len = 8 + 1 + strlen (hash->elf.root.root.string) + 1 + 8 + 1;
1327 stub_name = bfd_malloc (len);
1328 if (stub_name != NULL)
1329 sprintf (stub_name, "%08x_%s+%x",
1330 input_section->id & 0xffffffff,
1331 hash->elf.root.root.string,
1332 (int) rel->r_addend & 0xffffffff);
1333 }
1334 else
1335 {
1336 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
1337 stub_name = bfd_malloc (len);
1338 if (stub_name != NULL)
1339 sprintf (stub_name, "%08x_%x:%x+%x",
1340 input_section->id & 0xffffffff,
1341 sym_sec->id & 0xffffffff,
1342 (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
1343 (int) rel->r_addend & 0xffffffff);
1344 }
1345
1346 return stub_name;
1347 }
1348
1349 /* Determine the type of stub needed, if any, for a call. */
1350
1351 static enum elf32_csky_stub_type
1352 csky_type_of_stub (struct bfd_link_info *info,
1353 asection *input_sec,
1354 const Elf_Internal_Rela *rel,
1355 unsigned char st_type,
1356 struct csky_elf_link_hash_entry *hash,
1357 bfd_vma destination,
1358 asection *sym_sec ATTRIBUTE_UNUSED,
1359 bfd *input_bfd ATTRIBUTE_UNUSED,
1360 const char *name ATTRIBUTE_UNUSED)
1361 {
1362 bfd_vma location;
1363 bfd_signed_vma branch_offset;
1364 unsigned int r_type;
1365 enum elf32_csky_stub_type stub_type = csky_stub_none;
1366 struct elf_link_hash_entry * h = &hash->elf;
1367
1368 /* We don't know the actual type of destination in case it is of
1369 type STT_SECTION: give up. */
1370 if (st_type == STT_SECTION)
1371 return stub_type;
1372
1373 location = (input_sec->output_offset
1374 + input_sec->output_section->vma
1375 + rel->r_offset);
1376
1377 branch_offset = (bfd_signed_vma)(destination - location);
1378 r_type = ELF32_R_TYPE (rel->r_info);
1379 if (r_type == R_CKCORE_PCREL_IMM26BY2
1380 && ((h != NULL
1381 && ((h->def_dynamic && !h->def_regular)
1382 || (bfd_link_pic (info)
1383 && h->root.type == bfd_link_hash_defweak)))
1384 || branch_offset > BSR_MAX_FWD_BRANCH_OFFSET
1385 || branch_offset < BSR_MAX_BWD_BRANCH_OFFSET))
1386 {
1387 if (bfd_csky_arch (info->output_bfd) == CSKY_ARCH_810
1388 || bfd_csky_arch (info->output_bfd) == CSKY_ARCH_807)
1389 stub_type = csky_stub_long_branch_jmpi;
1390 else
1391 stub_type = csky_stub_long_branch;
1392 }
1393
1394 return stub_type;
1395 }
1396
1397 /* Create an entry in an C-SKY ELF linker hash table. */
1398
1399 static struct bfd_hash_entry *
1400 csky_elf_link_hash_newfunc (struct bfd_hash_entry * entry,
1401 struct bfd_hash_table * table,
1402 const char * string)
1403 {
1404 struct csky_elf_link_hash_entry * ret =
1405 (struct csky_elf_link_hash_entry *) entry;
1406
1407 /* Allocate the structure if it has not already been allocated by a
1408 subclass. */
1409 if (ret == NULL)
1410 {
1411 ret = (struct csky_elf_link_hash_entry *)
1412 bfd_hash_allocate (table,
1413 sizeof (struct csky_elf_link_hash_entry));
1414 if (ret == NULL)
1415 return (struct bfd_hash_entry *) ret;
1416 }
1417
1418 /* Call the allocation method of the superclass. */
1419 ret = ((struct csky_elf_link_hash_entry *)
1420 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *)ret,
1421 table, string));
1422 if (ret != NULL)
1423 {
1424 struct csky_elf_link_hash_entry *eh;
1425
1426 eh = (struct csky_elf_link_hash_entry *) ret;
1427 eh->plt_refcount = 0;
1428 eh->jsri2bsr_refcount = 0;
1429 eh->tls_type = GOT_NORMAL;
1430 ret->stub_cache = NULL;
1431 }
1432
1433 return (struct bfd_hash_entry *) ret;
1434 }
1435
1436 /* Initialize an entry in the stub hash table. */
1437
1438 static struct bfd_hash_entry *
1439 stub_hash_newfunc (struct bfd_hash_entry *entry,
1440 struct bfd_hash_table *table,
1441 const char *string)
1442 {
1443 /* Allocate the structure if it has not already been allocated by a
1444 subclass. */
1445 if (entry == NULL)
1446 {
1447 entry = ((struct bfd_hash_entry *)
1448 bfd_hash_allocate (table,
1449 sizeof (struct elf32_csky_stub_hash_entry)));
1450 if (entry == NULL)
1451 return entry;
1452 }
1453
1454 /* Call the allocation method of the superclass. */
1455 entry = bfd_hash_newfunc (entry, table, string);
1456 if (entry != NULL)
1457 {
1458 struct elf32_csky_stub_hash_entry *eh;
1459
1460 /* Initialize the local fields. */
1461 eh = (struct elf32_csky_stub_hash_entry *) entry;
1462 eh->stub_sec = NULL;
1463 eh->stub_offset = 0;
1464 eh->target_value = 0;
1465 eh->target_section = NULL;
1466 eh->target_addend = 0;
1467 eh->stub_type = csky_stub_none;
1468 eh->stub_size = 0;
1469 eh->stub_template = NULL;
1470 eh->stub_template_size = -1;
1471 eh->h = NULL;
1472 eh->id_sec = NULL;
1473 eh->output_name = NULL;
1474 }
1475
1476 return entry;
1477 }
1478
1479 /* Free the derived linker hash table. */
1480
1481 static void
1482 csky_elf_link_hash_table_free (bfd *obfd)
1483 {
1484 struct csky_elf_link_hash_table *ret
1485 = (struct csky_elf_link_hash_table *) obfd->link.hash;
1486
1487 bfd_hash_table_free (&ret->stub_hash_table);
1488 _bfd_elf_link_hash_table_free (obfd);
1489 }
1490
1491 /* Create an CSKY elf linker hash table. */
1492
1493 static struct bfd_link_hash_table *
1494 csky_elf_link_hash_table_create (bfd *abfd)
1495 {
1496 struct csky_elf_link_hash_table *ret;
1497 size_t amt = sizeof (struct csky_elf_link_hash_table);
1498
1499 ret = (struct csky_elf_link_hash_table*) bfd_zmalloc (amt);
1500 if (ret == NULL)
1501 return NULL;
1502
1503 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1504 csky_elf_link_hash_newfunc,
1505 sizeof (struct csky_elf_link_hash_entry)))
1506 {
1507 free (ret);
1508 return NULL;
1509 }
1510
1511 if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc,
1512 sizeof (struct elf32_csky_stub_hash_entry)))
1513 {
1514 free (ret);
1515 return NULL;
1516 }
1517 ret->elf.root.hash_table_free = csky_elf_link_hash_table_free;
1518 return &ret->elf.root;
1519 }
1520
1521 static bool
1522 csky_elf_mkobject (bfd *abfd)
1523 {
1524 return bfd_elf_allocate_object (abfd, sizeof (struct csky_elf_obj_tdata));
1525 }
1526
1527 /* Adjust a symbol defined by a dynamic object and referenced by a
1528 regular object. The current definition is in some section of the
1529 dynamic object, but we're not including those sections. We have to
1530 change the definition to something the rest of the link can
1531 understand. */
1532
1533 static bool
1534 csky_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1535 struct elf_link_hash_entry *h)
1536 {
1537 struct csky_elf_link_hash_entry *eh;
1538 struct csky_elf_link_hash_table *htab;
1539 asection *srel;
1540 asection *s;
1541 eh = (struct csky_elf_link_hash_entry *)h;
1542 if (eh == NULL)
1543 return false;
1544
1545 htab = csky_elf_hash_table (info);
1546 if (htab == NULL)
1547 return false;
1548
1549 /* Clear jsri2bsr_refcount, if creating shared library files. */
1550 if (bfd_link_pic (info) && eh->jsri2bsr_refcount > 0)
1551 eh->jsri2bsr_refcount = 0;
1552
1553 /* If there is a function, put it in the procedure linkage table. We
1554 will fill in the contents of the procedure linkage table later. */
1555 if (h->needs_plt)
1556 {
1557 /* Calls to STT_GNU_IFUNC symbols always use a PLT, even if the
1558 symbol binds locally. */
1559 if (h->plt.refcount <= 0
1560 || (h->type != STT_GNU_IFUNC
1561 && (SYMBOL_CALLS_LOCAL (info, h)
1562 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1563 && h->root.type == bfd_link_hash_undefweak))))
1564
1565 {
1566 /* This case can occur if we saw a PLT32 reloc in an input
1567 file, but the symbol was never referred to by a dynamic
1568 object, or if all references were garbage collected. In
1569 such a case, we don't actually need to build a procedure
1570 linkage table, and we can just do a PC32 reloc instead. */
1571 h->plt.offset = (bfd_vma) -1;
1572 h->needs_plt = 0;
1573 if (h->got.refcount == 0)
1574 h->got.refcount += 1;
1575 }
1576 else if (h->got.refcount != 0)
1577 {
1578 h->got.refcount -= eh->plt_refcount;
1579 eh->plt_refcount = 0;
1580 }
1581 return true;
1582 }
1583 else
1584 /* It's possible that we incorrectly decided a .plt reloc was
1585 needed for an R_CKCORE_PC32 or similar reloc to a non-function
1586 sym in check_relocs. We can't decide accurately between function
1587 and non-function syms in check_relocs; objects loaded later in
1588 the link may change h->type. So fix it now. */
1589 h->plt.offset = (bfd_vma) -1;
1590
1591 /* If this is a weak symbol, and there is a real definition, the
1592 processor independent code will have arranged for us to see the
1593 real definition first, and we can just use the same value. */
1594 if (h->is_weakalias)
1595 {
1596 struct elf_link_hash_entry *def = weakdef (h);
1597 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1598 h->root.u.def.section = def->root.u.def.section;
1599 h->root.u.def.value = def->root.u.def.value;
1600 return true;
1601 }
1602
1603 /* If there are no non-GOT references, we do not need a copy
1604 relocation. */
1605 if (!h->non_got_ref)
1606 return true;
1607
1608 /* This is a reference to a symbol defined by a dynamic object which
1609 is not a function. */
1610
1611 /* If we are creating a shared library, we must presume that the
1612 only references to the symbol are via the global offset table.
1613 For such cases we need not do anything here; the relocations will
1614 be handled correctly by relocate_section. */
1615 if (bfd_link_pic (info))
1616 return true;
1617
1618 /* We must allocate the symbol in our .dynbss section, which will
1619 become part of the .bss section of the executable. There will be
1620 an entry for this symbol in the .dynsym section. The dynamic
1621 object will contain position independent code, so all references
1622 from the dynamic object to this symbol will go through the global
1623 offset table. The dynamic linker will use the .dynsym entry to
1624 determine the address it must put in the global offset table, so
1625 both the dynamic object and the regular object will refer to the
1626 same memory location for the variable. */
1627 /* We must generate a R_CKCORE_COPY reloc to tell the dynamic linker to
1628 copy the initial value out of the dynamic object and into the
1629 runtime process image. We need to remember the offset into the
1630 .rela.bss section we are going to use. */
1631 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
1632 {
1633 s = htab->elf.sdynrelro;
1634 srel = htab->elf.sreldynrelro;
1635 }
1636 else
1637 {
1638 s = htab->elf.sdynbss;
1639 srel = htab->elf.srelbss;
1640 }
1641 if (info->nocopyreloc == 0
1642 && (h->root.u.def.section->flags & SEC_ALLOC) != 0
1643 && h->size != 0
1644 && srel != NULL
1645 && s != NULL)
1646 {
1647 srel->size += sizeof (Elf32_External_Rela);
1648 h->needs_copy = 1;
1649 return _bfd_elf_adjust_dynamic_copy (info, h, s);
1650 }
1651
1652 h->non_got_ref = 0;
1653 return true;
1654 }
1655
1656 /* Allocate space in .plt, .got and associated reloc sections for
1657 dynamic relocs. */
1658
1659 static bool
1660 csky_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1661 {
1662 struct bfd_link_info *info;
1663 struct csky_elf_link_hash_table *htab;
1664 struct csky_elf_link_hash_entry *eh;
1665 struct elf_dyn_relocs *p;
1666
1667 /* For indirect case, such as _ZdlPv to _ZdlPv@@GLIBCXX_3.4. */
1668 if (h->root.type == bfd_link_hash_indirect)
1669 return true;
1670
1671 if (h->root.type == bfd_link_hash_warning)
1672 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1673
1674
1675 info = (struct bfd_link_info *) inf;
1676 htab = csky_elf_hash_table (info);
1677 if (htab == NULL)
1678 return false;
1679 /*TODO: how to deal with weak symbol relocs. */
1680 if ((htab->elf.dynamic_sections_created || h->type == STT_GNU_IFUNC)
1681 && h->plt.refcount > 0)
1682 {
1683 /* Make sure this symbol is output as a dynamic symbol.
1684 Undefined weak syms won't yet be marked as dynamic. */
1685 if (h->dynindx == -1 && !h->forced_local
1686 && h->root.type == bfd_link_hash_undefweak
1687 && ! bfd_elf_link_record_dynamic_symbol (info, h))
1688 return false;
1689 if (bfd_link_pic (info) || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1690 {
1691 asection *splt = htab->elf.splt;
1692
1693 /* If this is the first .plt entry, make room for the special
1694 first entry. */
1695 if (splt->size == 0)
1696 {
1697 if (bfd_csky_abi (info->output_bfd) == CSKY_ABI_V1)
1698 splt->size += PLT_ENTRY_SIZE_P;
1699 else
1700 splt->size += PLT_ENTRY_SIZE;
1701 }
1702 h->plt.offset = splt->size;
1703
1704 /* If this symbol is not defined in a regular file, and we are
1705 not generating a shared library, then set the symbol to this
1706 location in the .plt. This is required to make function
1707 pointers compare as equal between the normal executable and
1708 the shared library. */
1709 if (!bfd_link_pic (info) && !h->def_regular)
1710 {
1711 h->root.u.def.section = splt;
1712 h->root.u.def.value = h->plt.offset;
1713 }
1714
1715 /* Make room for this entry. */
1716 if (bfd_csky_abi (info->output_bfd) == CSKY_ABI_V1)
1717 splt->size += PLT_ENTRY_SIZE_P;
1718 else
1719 splt->size += PLT_ENTRY_SIZE;
1720 /* We also need to make an entry in the .rela.plt section. */
1721 htab->elf.srelplt->size += sizeof (Elf32_External_Rela);
1722
1723 /* We also need to make an entry in the .got.plt section, which
1724 will be placed in the .got section by the linker script. */
1725 htab->elf.sgotplt->size += 4;
1726 }
1727 else
1728 {
1729 h->plt.offset = (bfd_vma) -1;
1730 h->needs_plt = 0;
1731 }
1732 }
1733 else
1734 {
1735 h->plt.offset = (bfd_vma) -1;
1736 h->needs_plt = 0;
1737 }
1738
1739 if (h->got.refcount > 0)
1740 {
1741 asection *sgot;
1742 bool dyn;
1743 int indx;
1744
1745 int tls_type = csky_elf_hash_entry (h)->tls_type;
1746 /* Make sure this symbol is output as a dynamic symbol.
1747 Undefined weak syms won't yet be marked as dynamic. */
1748 if (h->dynindx == -1 && !h->forced_local
1749 && h->root.type == bfd_link_hash_undefweak
1750 && ! bfd_elf_link_record_dynamic_symbol (info, h))
1751 return false;
1752
1753 sgot = htab->elf.sgot;
1754 h->got.offset = sgot->size;
1755 BFD_ASSERT (tls_type != GOT_UNKNOWN);
1756 if (tls_type == GOT_NORMAL)
1757 /* Non-TLS symbols need one GOT slot. */
1758 sgot->size += 4;
1759 else
1760 {
1761 if (tls_type & GOT_TLS_GD)
1762 /* R_CKCORE_TLS_GD32 needs 2 consecutive GOT slots. */
1763 sgot->size += 8;
1764 if (tls_type & GOT_TLS_IE)
1765 /* R_CKCORE_TLS_IE32 needs one GOT slot. */
1766 sgot->size += 4;
1767 }
1768 dyn = htab->elf.dynamic_sections_created;
1769 indx = 0;
1770 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
1771 && (! bfd_link_pic (info) || !SYMBOL_REFERENCES_LOCAL (info, h)))
1772 indx = h->dynindx;
1773
1774 if (tls_type != GOT_NORMAL
1775 && (bfd_link_pic (info) || indx != 0)
1776 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1777 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
1778 || h->root.type != bfd_link_hash_undefweak))
1779 {
1780 if (tls_type & GOT_TLS_IE)
1781 htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1782 if (tls_type & GOT_TLS_GD)
1783 htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1784 if ((tls_type & GOT_TLS_GD) && indx != 0)
1785 htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1786 }
1787 else if (((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1788 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
1789 || h->root.type != bfd_link_hash_undefweak)
1790 && (bfd_link_pic (info)
1791 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)
1792 || h->plt.offset == (bfd_vma) -1))
1793 htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1794 }
1795 else
1796 h->got.offset = (bfd_vma) -1;
1797
1798 eh = (struct csky_elf_link_hash_entry *) h;
1799 if (h->dyn_relocs == NULL)
1800 return true;
1801
1802 /* In the shared -Bsymbolic case, discard space allocated for
1803 dynamic pc-relative relocs against symbols which turn out to be
1804 defined in regular objects. For the normal shared case, discard
1805 space for pc-relative relocs that have become local due to symbol
1806 visibility changes. */
1807
1808 if (bfd_link_pic (info))
1809 {
1810 if (SYMBOL_CALLS_LOCAL (info, h))
1811 {
1812 struct elf_dyn_relocs **pp;
1813
1814 for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
1815 {
1816 p->count -= p->pc_count;
1817 p->pc_count = 0;
1818 if (p->count == 0)
1819 *pp = p->next;
1820 else
1821 pp = &p->next;
1822 }
1823 }
1824
1825 if (eh->jsri2bsr_refcount
1826 && h->root.type == bfd_link_hash_defined
1827 && h->dyn_relocs != NULL)
1828 h->dyn_relocs->count -= eh->jsri2bsr_refcount;
1829
1830 /* Also discard relocs on undefined weak syms with non-default
1831 visibility. */
1832 if (h->dyn_relocs != NULL
1833 && h->root.type == bfd_link_hash_undefweak)
1834 {
1835 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1836 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
1837 h->dyn_relocs = NULL;
1838
1839 /* Make sure undefined weak symbols are output as a dynamic
1840 symbol in PIEs. */
1841 else if (h->dynindx == -1
1842 && !h->forced_local
1843 && !bfd_elf_link_record_dynamic_symbol (info, h))
1844 return false;
1845 }
1846
1847 }
1848 else
1849 {
1850 /* For the non-shared case, discard space for relocs against
1851 symbols which turn out to need copy relocs or are not
1852 dynamic. */
1853
1854 if (!h->non_got_ref
1855 && ((h->def_dynamic && !h->def_regular)
1856 || (htab->elf.dynamic_sections_created
1857 && (h->root.type == bfd_link_hash_undefweak
1858 || h->root.type == bfd_link_hash_indirect
1859 || h->root.type == bfd_link_hash_undefined))))
1860 {
1861 /* Make sure this symbol is output as a dynamic symbol.
1862 Undefined weak syms won't yet be marked as dynamic. */
1863 if (h->dynindx == -1 && !h->forced_local
1864 && h->root.type == bfd_link_hash_undefweak)
1865 {
1866 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1867 return false;
1868 }
1869
1870 /* If that succeeded, we know we'll be keeping all the
1871 relocs. */
1872 if (h->dynindx != -1)
1873 goto keep;
1874 }
1875
1876 h->dyn_relocs = NULL;
1877
1878 keep: ;
1879 }
1880
1881 /* Finally, allocate space. */
1882 for (p = h->dyn_relocs; p != NULL; p = p->next)
1883 {
1884 asection *srelgot = htab->elf.srelgot;
1885 srelgot->size += p->count * sizeof (Elf32_External_Rela);
1886 }
1887
1888 return true;
1889 }
1890
1891 /* Set the sizes of the dynamic sections. */
1892
1893 static bool
1894 csky_elf_late_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1895 struct bfd_link_info *info)
1896 {
1897 struct csky_elf_link_hash_table *htab;
1898 bfd *dynobj;
1899 asection *s;
1900 bool relocs;
1901 bfd *ibfd;
1902
1903 htab = csky_elf_hash_table (info);
1904 if (htab == NULL)
1905 return false;
1906 dynobj = htab->elf.dynobj;
1907 if (dynobj == NULL)
1908 return true;
1909
1910 if (htab->elf.dynamic_sections_created)
1911 {
1912 /* Set the contents of the .interp section to the interpreter. */
1913 if (!bfd_link_pic (info) && !info->nointerp)
1914 {
1915 s = bfd_get_section_by_name (dynobj, ".interp");
1916 BFD_ASSERT (s != NULL);
1917 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1918 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1919 s->alloced = 1;
1920 }
1921 }
1922
1923 /* Set up .got offsets for local syms, and space for local dynamic
1924 relocs. */
1925 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
1926 {
1927 bfd_signed_vma *local_got_refcounts;
1928 bfd_signed_vma *end_local_got;
1929 bfd_size_type locsymcount;
1930 Elf_Internal_Shdr *symtab_hdr;
1931 asection *srelgot, *sgot;
1932 char *local_tls_type;
1933
1934 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1935 continue;
1936
1937 sgot = htab->elf.sgot;
1938 srelgot = htab->elf.srelgot;
1939
1940 for (s = ibfd->sections; s != NULL; s = s->next)
1941 {
1942 struct elf_dyn_relocs *p;
1943
1944 for (p = elf_section_data (s)->local_dynrel;
1945 p != NULL;
1946 p = p->next)
1947 {
1948 if (!bfd_is_abs_section (p->sec)
1949 && bfd_is_abs_section (p->sec->output_section))
1950 /* Input section has been discarded, either because
1951 it is a copy of a linkonce section or due to
1952 linker script /DISCARD/, so we'll be discarding
1953 the relocs too. */
1954 ;
1955 else if (p->count != 0)
1956 {
1957 srelgot->size += p->count * sizeof (Elf32_External_Rela);
1958 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1959 info->flags |= DF_TEXTREL;
1960 }
1961 }
1962 }
1963
1964 local_got_refcounts = elf_local_got_refcounts (ibfd);
1965 if (!local_got_refcounts)
1966 continue;
1967
1968 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1969 locsymcount = symtab_hdr->sh_info;
1970 end_local_got = local_got_refcounts + locsymcount;
1971 local_tls_type = csky_elf_local_got_tls_type (ibfd);
1972
1973 for (; local_got_refcounts < end_local_got;
1974 ++local_got_refcounts, ++local_tls_type)
1975 {
1976 if (*local_got_refcounts > 0)
1977 {
1978 /* GOT_TLS_GD and GOT_TLS_IE type for TLS, GOT_NORMAL type
1979 for GOT. If output file is shared library, we should output
1980 GOT_TLS_GD type relocation in .rel.got. */
1981 *local_got_refcounts = sgot->size;
1982 if (*local_tls_type & GOT_TLS_GD)
1983 /* TLS_GD relocs need an 8-byte structure in the GOT. */
1984 sgot->size += 8;
1985 if (*local_tls_type & GOT_TLS_IE)
1986 sgot->size += 4;
1987 if (*local_tls_type == GOT_NORMAL)
1988 sgot->size += 4;
1989 if (bfd_link_pic (info) || *local_tls_type == GOT_TLS_GD)
1990 srelgot->size += sizeof (Elf32_External_Rela);
1991 }
1992 else
1993 *local_got_refcounts = (bfd_vma) -1;
1994 }
1995 }
1996
1997 if (htab->tls_ldm_got.refcount > 0)
1998 {
1999 /* Allocate two GOT entries and one dynamic relocation (if necessary)
2000 for R_CSKY_TLS_LDM32 relocations. */
2001 htab->tls_ldm_got.offset = htab->elf.sgot->size;
2002 htab->elf.sgot->size += 8;
2003 if (bfd_link_pic (info))
2004 htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
2005 }
2006 else
2007 htab->tls_ldm_got.offset = -1;
2008
2009 /* Allocate global sym .plt and .got entries, and space for global
2010 sym dynamic relocs. */
2011 elf_link_hash_traverse (&htab->elf, csky_allocate_dynrelocs, info);
2012
2013 /* Check for GOT overflow. */
2014 if (check_got_overflow == 1
2015 && htab->elf.sgot->size + htab->elf.sgotplt->size > GOT_MAX_SIZE)
2016 {
2017 _bfd_error_handler (_("GOT table size out of range")); /* */
2018 return false;
2019 }
2020
2021 /* We now have determined the sizes of the various dynamic sections.
2022 Allocate memory for them. */
2023 relocs = false;
2024 for (s = dynobj->sections; s != NULL; s = s->next)
2025 {
2026 bool strip_section = true;
2027
2028 if ((s->flags & SEC_LINKER_CREATED) == 0)
2029 continue;
2030
2031 if (s == htab->elf.splt
2032 || s == htab->elf.sgot
2033 || s == htab->elf.sgotplt
2034 || s == htab->elf.sdynrelro
2035 || s == htab->elf.sreldynrelro)
2036 {
2037 /* Strip this section if we don't need it;
2038 see the comment below. */
2039 /* We'd like to strip these sections if they aren't needed, but if
2040 we've exported dynamic symbols from them we must leave them.
2041 It's too late to tell BFD to get rid of the symbols. */
2042
2043 if (htab->elf.hplt != NULL)
2044 strip_section = false;
2045 }
2046 else if (startswith (bfd_section_name (s), ".rel") )
2047 {
2048 if (s->size != 0 )
2049 relocs = true;
2050
2051 /* We use the reloc_count field as a counter if we need
2052 to copy relocs into the output file. */
2053 s->reloc_count = 0;
2054 }
2055 else
2056 /* It's not one of our sections, so don't allocate space. */
2057 continue;
2058
2059 /* Strip this section if we don't need it; see the
2060 comment below. */
2061 if (s->size == 0)
2062 {
2063 /* If we don't need this section, strip it from the
2064 output file. This is mostly to handle .rel.bss and
2065 .rel.plt. We must create both sections in
2066 create_dynamic_sections, because they must be created
2067 before the linker maps input sections to output
2068 sections. The linker does that before
2069 adjust_dynamic_symbol is called, and it is that
2070 function which decides whether anything needs to go
2071 into these sections. */
2072 if (strip_section)
2073 s->flags |= SEC_EXCLUDE;
2074 continue;
2075 }
2076
2077 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2078 continue;
2079
2080 /* Allocate memory for the section contents. We use bfd_zalloc
2081 here in case unused entries are not reclaimed before the
2082 section's contents are written out. This should not happen,
2083 but this way if it does, we get a R_CKCORE_NONE reloc instead
2084 of garbage. */
2085 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2086 if (s->contents == NULL)
2087 return false;
2088 s->alloced = 1;
2089 }
2090
2091 if (htab->elf.dynamic_sections_created)
2092 htab->elf.dt_pltgot_required = htab->elf.sgot->size != 0;
2093 return _bfd_elf_add_dynamic_tags (output_bfd, info, relocs);
2094 }
2095
2096 /* Finish up dynamic symbol handling. We set the contents of various
2097 dynamic sections here. */
2098
2099 static bool
2100 csky_elf_finish_dynamic_symbol (bfd *output_bfd,
2101 struct bfd_link_info *info,
2102 struct elf_link_hash_entry *h,
2103 Elf_Internal_Sym *sym)
2104 {
2105 struct csky_elf_link_hash_table *htab;
2106
2107 htab = csky_elf_hash_table (info);
2108
2109 /* Sanity check to make sure no unexpected symbol reaches here.
2110 This matches the test in csky_elf_relocate_section handling
2111 of GOT/PLT entries. */
2112 BFD_ASSERT (! (h->dynindx == -1
2113 && !h->forced_local
2114 && h->root.type != bfd_link_hash_undefweak
2115 && bfd_link_pic (info)));
2116
2117 if (h->plt.offset != (bfd_vma) -1)
2118 {
2119 bfd_vma plt_index;
2120 bfd_vma got_offset;
2121 Elf_Internal_Rela rel;
2122 bfd_byte *loc;
2123 asection *plt, *relplt, *gotplt;
2124
2125 plt = htab->elf.splt;
2126 relplt = htab->elf.srelplt;
2127 gotplt = htab->elf.sgotplt;
2128
2129 /* This symbol has an entry in the procedure linkage table. Set
2130 it up. */
2131 BFD_ASSERT (h->dynindx != -1
2132 || ((h->forced_local || bfd_link_executable (info))
2133 && h->def_regular));
2134 BFD_ASSERT (plt != NULL && gotplt != NULL && relplt != NULL);
2135 if (bfd_csky_abi (output_bfd) == CSKY_ABI_V2)
2136 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2137 else
2138 plt_index = h->plt.offset / PLT_ENTRY_SIZE_P - 1;
2139 got_offset = (plt_index + 3) * 4;
2140
2141 /* Fill in the entry in the procedure linkage table. */
2142 if (bfd_csky_abi (output_bfd) == CSKY_ABI_V2)
2143 {
2144 csky_put_insn_32 (output_bfd, csky_elf_plt_entry_v2[0],
2145 plt->contents + h->plt.offset);
2146 csky_put_insn_32 (output_bfd,
2147 (csky_elf_plt_entry_v2[1] | plt_index),
2148 plt->contents + h->plt.offset + 4);
2149 csky_put_insn_32 (output_bfd, csky_elf_plt_entry_v2[2],
2150 plt->contents + h->plt.offset + 8);
2151 }
2152 else
2153 {
2154 int i;
2155 for (i = 0; i < 6; i++)
2156 bfd_put_16 (output_bfd, csky_elf_plt_entry_v1[i],
2157 plt->contents + h->plt.offset + i * 2);
2158 bfd_put_32 (output_bfd, plt_index,
2159 plt->contents + h->plt.offset + i * 2);
2160 }
2161
2162 /* Fill in the entry in the .rel.plt section. */
2163 rel.r_offset = (htab->elf.sgotplt->output_section->vma
2164 + htab->elf.sgotplt->output_offset
2165 + got_offset);
2166 rel.r_info = ELF32_R_INFO (h->dynindx, R_CKCORE_JUMP_SLOT);
2167 rel.r_addend = (plt->output_section->vma
2168 + plt->output_offset
2169 + h->plt.offset);
2170 loc = (htab->elf.srelplt->contents
2171 + plt_index * sizeof (Elf32_External_Rela));
2172
2173 if (loc != NULL)
2174 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
2175 if (! h->def_regular)
2176 {
2177 /* Mark the symbol as undefined, rather than as defined in
2178 the .plt section. Leave the value alone. */
2179 sym->st_shndx = SHN_UNDEF;
2180 /* If the symbol is weak, we do need to clear the value.
2181 Otherwise, the PLT entry would provide a definition for
2182 the symbol even if the symbol wasn't defined anywhere,
2183 and so the symbol would never be NULL. Leave the value if
2184 there were any relocations where pointer equality matters
2185 (this is a clue for the dynamic linker, to make function
2186 pointer comparisons work between an application and shared
2187 library). */
2188 if (!h->ref_regular_nonweak || !h->pointer_equality_needed)
2189 sym->st_value = 0;
2190 }
2191 }
2192
2193 /* Fill in the entry in the .got section. */
2194 if (h->got.offset != (bfd_vma) -1
2195 && ((csky_elf_hash_entry (h)->tls_type & GOT_TLS_GD) == 0)
2196 && ((csky_elf_hash_entry (h)->tls_type & GOT_TLS_IE) == 0))
2197 {
2198 Elf_Internal_Rela rel;
2199 bfd_byte *loc;
2200
2201 /* This symbol has an entry in the global offset table.
2202 Set it up. */
2203 BFD_ASSERT (htab->elf.sgot != NULL && htab->elf.srelgot != NULL);
2204
2205 rel.r_offset = (htab->elf.sgot->output_section->vma
2206 + htab->elf.sgot->output_offset
2207 + (h->got.offset & ~(bfd_vma) 1));
2208
2209 /* If this is a static link, or it is a -Bsymbolic link and the
2210 symbol is defined locally or was forced to be local because
2211 of a version file, we just want to emit a RELATIVE reloc.
2212 The entry in the global offset table will already have been
2213 initialized in the relocate_section function. */
2214 if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h))
2215 {
2216 BFD_ASSERT ((h->got.offset & 1) != 0);
2217 rel.r_info = ELF32_R_INFO (0, R_CKCORE_RELATIVE);
2218 rel.r_addend = (h->root.u.def.value
2219 + h->root.u.def.section->output_offset
2220 + h->root.u.def.section->output_section->vma);
2221 }
2222 else
2223 {
2224 BFD_ASSERT ((h->got.offset & 1) == 0);
2225 bfd_put_32 (output_bfd, (bfd_vma) 0,
2226 htab->elf.sgot->contents + h->got.offset);
2227 rel.r_info = ELF32_R_INFO (h->dynindx, R_CKCORE_GLOB_DAT);
2228 rel.r_addend = 0;
2229 }
2230
2231 loc = htab->elf.srelgot->contents;
2232 loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
2233
2234 if (loc != NULL)
2235 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
2236 }
2237
2238 if (h->needs_copy)
2239 {
2240 asection *s;
2241 Elf_Internal_Rela rela;
2242 bfd_byte *loc;
2243
2244 /* This symbol needs a copy reloc. Set it up. */
2245 BFD_ASSERT (h->dynindx != -1
2246 && (h->root.type == bfd_link_hash_defined
2247 || h->root.type == bfd_link_hash_defweak));
2248
2249 rela.r_offset = (h->root.u.def.value
2250 + h->root.u.def.section->output_section->vma
2251 + h->root.u.def.section->output_offset);
2252 rela.r_info = ELF32_R_INFO (h->dynindx, R_CKCORE_COPY);
2253 rela.r_addend = 0;
2254 if (h->root.u.def.section == htab->elf.sdynrelro)
2255 s = htab->elf.sreldynrelro;
2256 else
2257 s = htab->elf.srelbss;
2258 BFD_ASSERT (s != NULL);
2259 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
2260 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2261 }
2262
2263 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2264 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2265 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2266 sym->st_shndx = SHN_ABS;
2267
2268 return true;
2269 }
2270
2271 /* Finish up the dynamic sections. */
2272
2273 static bool
2274 csky_elf_finish_dynamic_sections (bfd *output_bfd,
2275 struct bfd_link_info *info)
2276 {
2277 struct csky_elf_link_hash_table *htab;
2278 bfd *dynobj;
2279 asection *sdyn;
2280 asection *got_sec;
2281
2282 htab = csky_elf_hash_table (info);
2283 if (htab == NULL)
2284 return false;
2285
2286 dynobj = htab->elf.dynobj;
2287 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2288
2289 if (htab->elf.dynamic_sections_created)
2290 {
2291 Elf32_External_Dyn *dyncon, *dynconend;
2292
2293 BFD_ASSERT (sdyn != NULL && htab->elf.sgot != NULL);
2294
2295 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2296 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2297 for (; dyncon < dynconend; dyncon++)
2298 {
2299 Elf_Internal_Dyn dyn;
2300 bool size = false;
2301 const char *name = NULL;
2302
2303 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2304 switch (dyn.d_tag)
2305 {
2306 default:
2307 continue;
2308 case DT_RELA:
2309 name = ".rela.dyn";
2310 size = false;
2311 break;
2312 case DT_RELASZ:
2313 name = ".rela.dyn";
2314 size = true;
2315 break;
2316 case DT_PLTRELSZ:
2317 name = ".rela.plt";
2318 size = true;
2319 break;
2320 case DT_PLTGOT:
2321 dyn.d_un.d_ptr = htab->elf.sgot->output_section->vma;
2322 break;
2323 case DT_JMPREL:
2324 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma
2325 + htab->elf.srelplt->output_offset;
2326 break;
2327 }
2328
2329 if (name != NULL)
2330 {
2331 asection *s = bfd_get_section_by_name (output_bfd, name);
2332
2333 if (s == NULL)
2334 dyn.d_un.d_val = 0;
2335 else if (!size)
2336 dyn.d_un.d_ptr = s->vma;
2337 else
2338 dyn.d_un.d_val = s->size;
2339 }
2340 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2341 }
2342 }
2343
2344 /* Fill in the first three entries in the global offset table. */
2345 if (htab->elf.sgotplt)
2346 got_sec = htab->elf.sgotplt;
2347 else
2348 got_sec = htab->elf.sgot;
2349 if (got_sec != NULL)
2350 {
2351 if (got_sec->size > 0)
2352 {
2353 bfd_put_32 (output_bfd,
2354 (sdyn == NULL ? (bfd_vma) 0
2355 : sdyn->output_section->vma + sdyn->output_offset),
2356 got_sec->contents);
2357 bfd_put_32 (output_bfd, (bfd_vma) 0, got_sec->contents + 4);
2358 bfd_put_32 (output_bfd, (bfd_vma) 0, got_sec->contents + 8);
2359 }
2360 elf_section_data (got_sec->output_section)->this_hdr.sh_entsize = 4;
2361 }
2362 return true;
2363 }
2364
2365 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2366
2367 static void
2368 csky_elf_copy_indirect_symbol (struct bfd_link_info *info,
2369 struct elf_link_hash_entry *dir,
2370 struct elf_link_hash_entry *ind)
2371 {
2372 struct csky_elf_link_hash_entry *edir, *eind;
2373
2374 edir = (struct csky_elf_link_hash_entry *) dir;
2375 eind = (struct csky_elf_link_hash_entry *) ind;
2376
2377 if (ind->root.type == bfd_link_hash_indirect
2378 && dir->got.refcount <= 0)
2379 {
2380 edir->tls_type = eind->tls_type;
2381 eind->tls_type = GOT_UNKNOWN;
2382 }
2383 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2384 }
2385
2386 /* Used to decide how to sort relocs in an optimal manner for the
2387 dynamic linker, before writing them out. */
2388
2389 static enum elf_reloc_type_class
2390 csky_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2391 const asection *rel_sec ATTRIBUTE_UNUSED,
2392 const Elf_Internal_Rela *rela)
2393 {
2394 switch ((int) ELF32_R_TYPE (rela->r_info))
2395 {
2396 case R_CKCORE_RELATIVE:
2397 return reloc_class_relative;
2398 case R_CKCORE_JUMP_SLOT:
2399 return reloc_class_plt;
2400 case R_CKCORE_COPY:
2401 return reloc_class_copy;
2402 case R_CKCORE_IRELATIVE:
2403 return reloc_class_ifunc;
2404 default:
2405 return reloc_class_normal;
2406 }
2407 }
2408
2409 /* Return the section that should be marked against GC for a given
2410 relocation. */
2411
2412 static asection *
2413 csky_elf_gc_mark_hook (asection *sec,
2414 struct bfd_link_info *info,
2415 Elf_Internal_Rela *rel,
2416 struct elf_link_hash_entry *h,
2417 Elf_Internal_Sym *sym)
2418 {
2419 if (h != NULL)
2420 {
2421 switch (ELF32_R_TYPE (rel->r_info))
2422 {
2423 case R_CKCORE_GNU_VTINHERIT:
2424 case R_CKCORE_GNU_VTENTRY:
2425 return NULL;
2426 }
2427 }
2428
2429 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2430 }
2431
2432 /* Match symbol names created by tc-csky.c:make_mapping_symbol. */
2433
2434 static bool
2435 is_mapping_symbol_name (const char *name)
2436 {
2437 return (name && name[0] == '$'
2438 && (name[1] == 't' || name[1] == 'd')
2439 && name[2] == 0);
2440 }
2441
2442 /* Treat mapping symbols as special target symbols. */
2443
2444 static bool
2445 csky_elf_is_target_special_symbol (bfd *abfd ATTRIBUTE_UNUSED, asymbol *sym)
2446 {
2447 return is_mapping_symbol_name (sym->name);
2448 }
2449
2450 /* Exclude mapping symbols from being treated as function symbols by
2451 objdump and nm. */
2452
2453 static bfd_size_type
2454 csky_elf_maybe_function_sym (const asymbol *sym, asection *sec,
2455 bfd_vma *code_off)
2456 {
2457 if ((sym->flags & BSF_LOCAL) != 0
2458 && is_mapping_symbol_name (sym->name))
2459 return 0;
2460
2461 return _bfd_elf_maybe_function_sym (sym, sec, code_off);
2462 }
2463
2464 /* Look through the relocs for a section during the first phase.
2465 Since we don't do .gots or .plts, we just need to consider the
2466 virtual table relocs for gc. */
2467
2468 static bool
2469 csky_elf_check_relocs (bfd * abfd,
2470 struct bfd_link_info * info,
2471 asection * sec,
2472 const Elf_Internal_Rela * relocs)
2473 {
2474 Elf_Internal_Shdr * symtab_hdr;
2475 struct elf_link_hash_entry ** sym_hashes;
2476 const Elf_Internal_Rela * rel;
2477 const Elf_Internal_Rela * rel_end;
2478 struct csky_elf_link_hash_table *htab;
2479 asection *sreloc;
2480
2481 /* if output type is relocatable, return. */
2482 if (bfd_link_relocatable (info))
2483 return true;
2484
2485 htab = csky_elf_hash_table (info);
2486 if (htab == NULL)
2487 return false;
2488
2489 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
2490 sym_hashes = elf_sym_hashes (abfd);
2491
2492 rel_end = relocs + sec->reloc_count;
2493 sreloc = NULL;
2494 for (rel = relocs; rel < rel_end; rel++)
2495 {
2496 struct elf_link_hash_entry *h;
2497 unsigned long r_symndx;
2498 Elf_Internal_Sym *isym;
2499 int r_type;
2500
2501 r_symndx = ELF32_R_SYM (rel->r_info);
2502 r_type = ELF32_R_TYPE (rel->r_info);
2503 if (r_symndx < symtab_hdr->sh_info)
2504 {
2505 /* A local symbol. */
2506 isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache,
2507 abfd, r_symndx);
2508 if (isym == NULL)
2509 return false;
2510 h = NULL;
2511 }
2512 else
2513 {
2514 isym = NULL;
2515 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2516 while (h->root.type == bfd_link_hash_indirect
2517 || h->root.type == bfd_link_hash_warning)
2518 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2519 }
2520
2521 switch (r_type)
2522 {
2523 case R_CKCORE_PCREL_IMM26BY2:
2524 case R_CKCORE_PCREL_IMM11BY2:
2525 case R_CKCORE_PCREL_JSR_IMM11BY2:
2526 case R_CKCORE_PCREL_JSR_IMM26BY2:
2527 /* If the symbol is '*UND*', means this reloc is used for
2528 * callgraph, don't need to leave to shared object. */
2529 if (r_symndx == 0)
2530 break;
2531 /* Else fall through. */
2532 case R_CKCORE_ADDR32:
2533 case R_CKCORE_ADDR_HI16:
2534 case R_CKCORE_ADDR_LO16:
2535 if (h != NULL
2536 && bfd_link_executable (info)
2537 && r_type == R_CKCORE_ADDR32
2538 && h->type == STT_OBJECT
2539 && (sec->flags & SEC_ALLOC) != 0
2540 && (sec->flags & SEC_READONLY))
2541 /* If this reloc is in a read-only section, we might
2542 need a copy reloc. We can't check reliably at this
2543 stage whether the section is read-only, as input
2544 sections have not yet been mapped to output sections.
2545 Tentatively set the flag for now, and correct in
2546 adjust_dynamic_symbol. */
2547 h->non_got_ref = 1;
2548
2549 /* If we are creating a shared library or relocatable executable,
2550 and this is a reloc against a global symbol, then we need to
2551 copy the reloc into the shared library. However, if we are
2552 linking with -Bsymbolic, we do not need to copy a reloc
2553 against a global symbol which is defined in an object we are
2554 including in the link (i.e., DEF_REGULAR is set). At
2555 this point we have not seen all the input files, so it is
2556 possible that DEF_REGULAR is not set now but will be set
2557 later (it is never cleared). We account for that possibility
2558 below by storing information in the relocs_copied field of
2559 the hash table entry. */
2560 if ((bfd_link_pic (info) && (sec->flags & SEC_ALLOC) != 0)
2561 || (!bfd_link_pic (info)
2562 && (sec->flags & SEC_ALLOC) != 0
2563 && h != NULL
2564 && (h->root.type == bfd_link_hash_defweak
2565 || !h->def_regular)))
2566 {
2567 struct elf_dyn_relocs *p;
2568 struct elf_dyn_relocs **head;
2569 /* We must copy these reloc types into the output file.
2570 Create a reloc section in dynobj and make room for
2571 this reloc. */
2572 if (sreloc == NULL)
2573 {
2574 if (htab->elf.dynobj == NULL)
2575 htab->elf.dynobj = abfd;
2576
2577 sreloc = _bfd_elf_make_dynamic_reloc_section
2578 (sec, htab->elf.dynobj, 2, abfd, true);
2579
2580 if (sreloc == NULL)
2581 return false;
2582 }
2583
2584 if (h == NULL && !use_branch_stub
2585 && ((ELF32_R_TYPE (rel->r_info)
2586 == R_CKCORE_PCREL_IMM26BY2)
2587 || (ELF32_R_TYPE (rel->r_info)
2588 == R_CKCORE_PCREL_IMM11BY2)))
2589 break;
2590
2591 /* If this is a global symbol, we count the number of
2592 relocations we need for this symbol. */
2593 if (h != NULL)
2594 {
2595 struct csky_elf_link_hash_entry *eh;
2596 eh = (struct csky_elf_link_hash_entry *)h;
2597 if ((ELF32_R_TYPE (rel->r_info)
2598 == R_CKCORE_PCREL_JSR_IMM26BY2)
2599 || (ELF32_R_TYPE (rel->r_info)
2600 == R_CKCORE_PCREL_JSR_IMM11BY2))
2601 eh->jsri2bsr_refcount += 1;
2602 head = &h->dyn_relocs;
2603 }
2604 else
2605 {
2606 /* Track dynamic relocs needed for local syms too.
2607 We really need local syms available to do this
2608 easily. Oh well. */
2609 void **vpp;
2610 asection *s;
2611 Elf_Internal_Sym *loc_isym;
2612
2613 loc_isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache,
2614 abfd, r_symndx);
2615 if (loc_isym == NULL)
2616 return false;
2617 s = bfd_section_from_elf_index (abfd, loc_isym->st_shndx);
2618 if (s == NULL)
2619 s = sec;
2620 vpp = &elf_section_data (s)->local_dynrel;
2621 head = (struct elf_dyn_relocs **)vpp;
2622 }
2623
2624 p = *head;
2625 if (p == NULL || p->sec != sec)
2626 {
2627 size_t amt = sizeof *p;
2628 p = ((struct elf_dyn_relocs *)
2629 bfd_alloc (htab->elf.dynobj, amt));
2630 if (p == NULL)
2631 return false;
2632 p->next = *head;
2633 *head = p;
2634 p->sec = sec;
2635 p->count = 0;
2636 p->pc_count = 0;
2637 }
2638
2639 if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_PCREL_IMM26BY2
2640 || ELF32_R_TYPE (rel->r_info) == R_CKCORE_PCREL_IMM11BY2)
2641 p->pc_count += 1;
2642 p->count += 1;
2643 }
2644 break;
2645
2646 case R_CKCORE_PLT_IMM18BY4:
2647 case R_CKCORE_PLT32:
2648 /* This symbol requires a procedure linkage table entry. We
2649 actually build the entry in adjust_dynamic_symbol,
2650 because this might be a case of linking PIC code which is
2651 never referenced by a dynamic object, in which case we
2652 don't need to generate a procedure linkage table entry
2653 after all. */
2654
2655 /* If this is a local symbol, we resolve it directly without
2656 creating a procedure linkage table entry. */
2657 if (h == NULL)
2658 continue;
2659 if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_PLT_IMM18BY4)
2660 check_got_overflow = 1;
2661
2662 h->needs_plt = 1;
2663 h->plt.refcount += 1;
2664 h->got.refcount += 1;
2665 ((struct csky_elf_link_hash_entry *)h)->plt_refcount += 1;
2666 break;
2667
2668 case R_CKCORE_GOT12:
2669 case R_CKCORE_PLT12:
2670 case R_CKCORE_GOT32:
2671 case R_CKCORE_GOT_HI16:
2672 case R_CKCORE_GOT_LO16:
2673 case R_CKCORE_PLT_HI16:
2674 case R_CKCORE_PLT_LO16:
2675 case R_CKCORE_GOT_IMM18BY4:
2676 case R_CKCORE_TLS_IE32:
2677 case R_CKCORE_TLS_GD32:
2678 {
2679 int tls_type, old_tls_type;
2680
2681 if (h != NULL
2682 && bfd_link_executable (info)
2683 && r_type == R_CKCORE_GOT_IMM18BY4
2684 && (sec->flags & SEC_ALLOC) != 0
2685 && (sec->flags & SEC_READONLY))
2686 /* If this reloc is in a read-only section, we might
2687 need a copy reloc. We can't check reliably at this
2688 stage whether the section is read-only, as input
2689 sections have not yet been mapped to output sections.
2690 Tentatively set the flag for now, and correct in
2691 adjust_dynamic_symbol. */
2692 h->non_got_ref = 1;
2693
2694 switch (ELF32_R_TYPE (rel->r_info))
2695 {
2696 case R_CKCORE_TLS_IE32:
2697 tls_type = GOT_TLS_IE;
2698 break;
2699 case R_CKCORE_TLS_GD32:
2700 tls_type = GOT_TLS_GD;
2701 break;
2702 default:
2703 tls_type = GOT_NORMAL;
2704 break;
2705 }
2706 if (h != NULL)
2707 {
2708 if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_GOT_IMM18BY4)
2709 check_got_overflow = 1;
2710 h->got.refcount += 1;
2711 old_tls_type = csky_elf_hash_entry (h)->tls_type;
2712 }
2713 else
2714 {
2715 bfd_signed_vma *local_got_refcounts;
2716
2717 /* This is a global offset table entry for a local symbol. */
2718 /* we can write a new function named
2719 elf32_csky_allocate_local_sym_info() to replace
2720 following code. */
2721 local_got_refcounts = elf_local_got_refcounts (abfd);
2722 if (local_got_refcounts == NULL)
2723 {
2724 bfd_size_type size;
2725
2726 size = symtab_hdr->sh_info;
2727 size *= (sizeof (bfd_signed_vma) + sizeof (char));
2728 local_got_refcounts = ((bfd_signed_vma *)
2729 bfd_zalloc (abfd, size));
2730 if (local_got_refcounts == NULL)
2731 return false;
2732 elf_local_got_refcounts (abfd) = local_got_refcounts;
2733 csky_elf_local_got_tls_type (abfd)
2734 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
2735 }
2736 local_got_refcounts[r_symndx] += 1;
2737 old_tls_type = csky_elf_local_got_tls_type (abfd)[r_symndx];
2738 }
2739
2740 /* We will already have issued an error message if there is a
2741 TLS / non-TLS mismatch, based on the symbol type. We don't
2742 support any linker relaxations. So just combine any TLS
2743 types needed. */
2744 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
2745 && tls_type != GOT_NORMAL)
2746 tls_type |= old_tls_type;
2747
2748 if (old_tls_type != tls_type)
2749 {
2750 if (h != NULL)
2751 csky_elf_hash_entry (h)->tls_type = tls_type;
2752 else
2753 csky_elf_local_got_tls_type (abfd)[r_symndx] = tls_type;
2754 }
2755 }
2756 /* Fall through. */
2757
2758 case R_CKCORE_TLS_LDM32:
2759 if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_TLS_LDM32)
2760 htab->tls_ldm_got.refcount++;
2761 /* Fall through. */
2762
2763 case R_CKCORE_GOTOFF:
2764 case R_CKCORE_GOTPC:
2765 case R_CKCORE_GOTOFF_HI16:
2766 case R_CKCORE_GOTOFF_LO16:
2767 case R_CKCORE_GOTPC_HI16:
2768 case R_CKCORE_GOTPC_LO16:
2769 case R_CKCORE_GOTOFF_IMM18:
2770 if (htab->elf.sgot == NULL)
2771 {
2772 if (htab->elf.dynobj == NULL)
2773 htab->elf.dynobj = abfd;
2774 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
2775 return false;
2776 }
2777 break;
2778
2779 /* This relocation describes the C++ object vtable hierarchy.
2780 Reconstruct it for later use during GC. */
2781 case R_CKCORE_GNU_VTINHERIT:
2782 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2783 return false;
2784 break;
2785
2786 /* This relocation describes which C++ vtable entries are actually
2787 used. Record for later use during GC. */
2788 case R_CKCORE_GNU_VTENTRY:
2789 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2790 return false;
2791 break;
2792 }
2793 }
2794
2795 return true;
2796 }
2797
2798 static const struct bfd_elf_special_section csky_elf_special_sections[]=
2799 {
2800 { STRING_COMMA_LEN (".ctors"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2801 { STRING_COMMA_LEN (".dtors"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2802 { NULL, 0, 0, 0, 0 }
2803 };
2804
2805 /* Function to keep CSKY specific flags in the ELF header. */
2806
2807 static bool
2808 csky_elf_set_private_flags (bfd * abfd, flagword flags)
2809 {
2810 BFD_ASSERT (! elf_flags_init (abfd)
2811 || elf_elfheader (abfd)->e_flags == flags);
2812
2813 elf_elfheader (abfd)->e_flags = flags;
2814 elf_flags_init (abfd) = true;
2815 return true;
2816 }
2817
2818 static csky_arch_for_merge *
2819 csky_find_arch_with_eflag (const unsigned long arch_eflag)
2820 {
2821 csky_arch_for_merge *csky_arch = NULL;
2822
2823 for (csky_arch = csky_archs; csky_arch->name != NULL; csky_arch++)
2824 if (csky_arch->arch_eflag == arch_eflag)
2825 break;
2826 if (csky_arch == NULL)
2827 {
2828 _bfd_error_handler (_("warning: unrecognized arch eflag '%#lx'"),
2829 arch_eflag);
2830 bfd_set_error (bfd_error_wrong_format);
2831 }
2832 return csky_arch;
2833 }
2834
2835 static csky_arch_for_merge *
2836 csky_find_arch_with_name (const char *name)
2837 {
2838 csky_arch_for_merge *csky_arch = NULL;
2839 const char *msg;
2840
2841 if (name == NULL)
2842 return NULL;
2843
2844 for (csky_arch = csky_archs; csky_arch->name != NULL; csky_arch++)
2845 {
2846 if (strncmp (csky_arch->name, name, strlen (csky_arch->name)) == 0)
2847 break;
2848 }
2849 if (csky_arch == NULL)
2850 {
2851 msg = _("warning: unrecognised arch name '%#x'");
2852 (*_bfd_error_handler) (msg, name);
2853 bfd_set_error (bfd_error_wrong_format);
2854 }
2855 return csky_arch;
2856 }
2857
2858 static bool
2859 elf32_csky_merge_attributes (bfd *ibfd, struct bfd_link_info *info)
2860 {
2861 bfd *obfd = info->output_bfd;
2862 obj_attribute *in_attr;
2863 obj_attribute *out_attr;
2864 csky_arch_for_merge *old_arch = NULL;
2865 csky_arch_for_merge *new_arch = NULL;
2866 int i;
2867 bool result = true;
2868 const char *msg = NULL;
2869
2870 const char *sec_name = get_elf_backend_data (ibfd)->obj_attrs_section;
2871
2872 /* Skip the linker stubs file. This preserves previous behavior
2873 of accepting unknown attributes in the first input file - but
2874 is that a bug? */
2875 if (ibfd->flags & BFD_LINKER_CREATED)
2876 return true;
2877
2878 /* Skip any input that hasn't attribute section.
2879 This enables to link object files without attribute section with
2880 any others. */
2881 if (bfd_get_section_by_name (ibfd, sec_name) == NULL)
2882 {
2883 return true;
2884 }
2885
2886 if (!elf_known_obj_attributes_proc (obfd)[0].i)
2887 {
2888 /* This is the first object. Copy the attributes. */
2889 out_attr = elf_known_obj_attributes_proc (obfd);
2890
2891 _bfd_elf_copy_obj_attributes (ibfd, obfd);
2892
2893 /* Use the Tag_null value to indicate the attributes have been
2894 initialized. */
2895 out_attr[0].i = 1;
2896 }
2897
2898 in_attr = elf_known_obj_attributes_proc (ibfd);
2899 out_attr = elf_known_obj_attributes_proc (obfd);
2900
2901 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
2902 {
2903 /* Merge this attribute with existing attributes. */
2904 switch (i)
2905 {
2906 case Tag_CSKY_CPU_NAME:
2907 case Tag_CSKY_ARCH_NAME:
2908 /* Do arch merge. */
2909 new_arch = csky_find_arch_with_name (in_attr[Tag_CSKY_ARCH_NAME].s);
2910 old_arch = csky_find_arch_with_name (out_attr[Tag_CSKY_ARCH_NAME].s);
2911
2912 if (new_arch != NULL && old_arch != NULL)
2913 {
2914 if (new_arch->class != old_arch->class)
2915 {
2916 msg = _("%pB: machine flag conflict with target");
2917 (*_bfd_error_handler) (msg, ibfd);
2918 bfd_set_error (bfd_error_wrong_format);
2919 return false;
2920 }
2921 else if (new_arch->class_level != old_arch->class_level)
2922 {
2923 csky_arch_for_merge *newest_arch =
2924 ((new_arch->class_level > old_arch->class_level) ?
2925 new_arch : old_arch);
2926
2927 if (new_arch->do_warning || old_arch->do_warning)
2928 {
2929 msg = _("warning: file %pB's arch flag %s conflict "
2930 "with target %s,set target arch flag to %s");
2931 (*_bfd_error_handler) (msg, ibfd, new_arch->name,
2932 old_arch->name,
2933 (newest_arch->name));
2934 bfd_set_error (bfd_error_wrong_format);
2935 }
2936
2937 if (out_attr[Tag_CSKY_ARCH_NAME].s != NULL)
2938 bfd_release (obfd, out_attr[Tag_CSKY_ARCH_NAME].s);
2939
2940 out_attr[Tag_CSKY_ARCH_NAME].s =
2941 _bfd_elf_attr_strdup (obfd, newest_arch->name);
2942 }
2943 }
2944
2945 break;
2946
2947 case Tag_CSKY_ISA_FLAGS:
2948 case Tag_CSKY_ISA_EXT_FLAGS:
2949 /* Do ISA merge. */
2950 break;
2951
2952 case Tag_CSKY_VDSP_VERSION:
2953 if (out_attr[i].i == 0)
2954 out_attr[i].i = in_attr[i].i;
2955 else if (out_attr[i].i != in_attr[i].i)
2956 {
2957 _bfd_error_handler
2958 (_("Error: %pB and %pB has different VDSP version"), ibfd, obfd);
2959 result = false;
2960 }
2961 break;
2962
2963 case Tag_CSKY_FPU_VERSION:
2964 if (out_attr[i].i <= in_attr[i].i
2965 && out_attr[i].i == 0)
2966 out_attr[i].i = in_attr[i].i;
2967 break;
2968
2969 case Tag_CSKY_DSP_VERSION:
2970 if (out_attr[i].i == 0)
2971 out_attr[i].i = in_attr[i].i;
2972 else if (out_attr[i].i != in_attr[i].i)
2973 {
2974 _bfd_error_handler
2975 (_("Error: %pB and %pB has different DSP version"), ibfd, obfd);
2976 result = false;
2977 }
2978 break;
2979
2980 case Tag_CSKY_FPU_ABI:
2981 if (out_attr[i].i != in_attr[i].i
2982 && (out_attr[i].i == 0
2983 || (out_attr[i].i == VAL_CSKY_FPU_ABI_SOFT
2984 && in_attr[i].i == VAL_CSKY_FPU_ABI_SOFTFP)))
2985 {
2986 out_attr[i].i = in_attr[i].i;
2987 }
2988 else if (out_attr[i].i == VAL_CSKY_FPU_ABI_HARD
2989 && (out_attr[i].i != in_attr[i].i
2990 && in_attr[i].i != 0))
2991 {
2992 _bfd_error_handler
2993 (_("Error: %pB and %pB has different FPU ABI"), ibfd, obfd);
2994 result = false;
2995 }
2996 break;
2997
2998 default:
2999 result =
3000 result && _bfd_elf_merge_unknown_attribute_low (ibfd, obfd, i);
3001 break;
3002 }
3003
3004 /* If out_attr was copied from in_attr then it won't have a type yet. */
3005 if (in_attr[i].type && !out_attr[i].type)
3006 out_attr[i].type = in_attr[i].type;
3007 }
3008
3009 /* Merge Tag_compatibility attributes and any common GNU ones. */
3010 if (!_bfd_elf_merge_object_attributes (ibfd, info))
3011 return false;
3012
3013 /* Check for any attributes not known on CSKY. */
3014 result &= _bfd_elf_merge_unknown_attribute_list (ibfd, obfd);
3015
3016 return result;
3017 }
3018
3019 /* Merge backend specific data from an object file to the output
3020 object file when linking. */
3021
3022 static bool
3023 csky_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
3024 {
3025 bfd *obfd = info->output_bfd;
3026 flagword old_flags;
3027 flagword new_flags;
3028 csky_arch_for_merge *old_arch = NULL;
3029 csky_arch_for_merge *new_arch = NULL;
3030 flagword newest_flag = 0;
3031 const char *sec_name;
3032 obj_attribute *out_attr;
3033
3034 /* Check if we have the same endianness. */
3035 if (! _bfd_generic_verify_endian_match (ibfd, info))
3036 return false;
3037
3038 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3039 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3040 return true;
3041
3042 /* Merge ".csky.attribute" section. */
3043 if (!elf32_csky_merge_attributes (ibfd, info))
3044 return false;
3045
3046 if (! elf_flags_init (obfd))
3047 {
3048 /* First call, no flags set. */
3049 elf_flags_init (obfd) = true;
3050 }
3051
3052 /* Try to merge e_flag. */
3053 new_flags = elf_elfheader (ibfd)->e_flags;
3054 old_flags = elf_elfheader (obfd)->e_flags;
3055 out_attr = elf_known_obj_attributes_proc (obfd);
3056
3057 /* The flags like "e , f ,g ..." , we take collection. */
3058 newest_flag = old_flags | new_flags;
3059
3060 sec_name = get_elf_backend_data (ibfd)->obj_attrs_section;
3061
3062 if (bfd_get_section_by_name (ibfd, sec_name) == NULL
3063 || ((new_flags & (CSKY_ARCH_MASK | CSKY_ABI_MASK)) !=
3064 (old_flags & (CSKY_ARCH_MASK | CSKY_ABI_MASK))))
3065 {
3066 /* Input BFDs have no ".csky.attribute" section. */
3067 new_arch = csky_find_arch_with_eflag (new_flags & CSKY_ARCH_MASK);
3068 old_arch = csky_find_arch_with_name (out_attr[Tag_CSKY_ARCH_NAME].s);
3069
3070 if (new_arch != NULL && old_arch != NULL)
3071 {
3072 if (new_arch->class != old_arch->class)
3073 {
3074 _bfd_error_handler
3075 /* xgettext:c-format */
3076 (_("%pB: machine flag conflict with target"), ibfd);
3077 bfd_set_error (bfd_error_wrong_format);
3078 return false;
3079 }
3080 else if (new_arch->class_level != old_arch->class_level)
3081 {
3082 csky_arch_for_merge *newest_arch =
3083 (new_arch->class_level > old_arch->class_level
3084 ? new_arch : old_arch);
3085
3086 if (new_arch->do_warning || old_arch->do_warning)
3087 {
3088 _bfd_error_handler
3089 /* xgettext:c-format */
3090 (_("warning: file %pB's arch flag %s conflicts with "
3091 "target ck%s, using %s"),
3092 ibfd, new_arch->name, old_arch->name,
3093 newest_arch->name);
3094 bfd_set_error (bfd_error_wrong_format);
3095 }
3096
3097 if (out_attr[Tag_CSKY_ARCH_NAME].s != NULL)
3098 bfd_release (obfd, out_attr[Tag_CSKY_ARCH_NAME].s);
3099
3100 out_attr[Tag_CSKY_ARCH_NAME].s =
3101 _bfd_elf_attr_strdup (obfd, newest_arch->name);
3102 }
3103 }
3104 else
3105 {
3106 if (new_arch && new_arch->name != NULL)
3107 out_attr[Tag_CSKY_ARCH_NAME].s =
3108 _bfd_elf_attr_strdup (obfd, new_arch->name);
3109 }
3110 }
3111
3112 elf_elfheader (obfd)->e_flags = newest_flag;
3113
3114 return true;
3115 }
3116
3117 /* Ignore the discarded relocs in special sections in link time. */
3118
3119 static bool
3120 csky_elf_ignore_discarded_relocs (asection *sec)
3121 {
3122 if (strcmp (sec->name, ".csky_stack_size") == 0)
3123 return true;
3124 return false;
3125 }
3126
3127 /* .csky_stack_size are not referenced directly. This pass marks all of
3128 them as required. */
3129
3130 static bool
3131 elf32_csky_gc_mark_extra_sections (struct bfd_link_info *info,
3132 elf_gc_mark_hook_fn gc_mark_hook ATTRIBUTE_UNUSED)
3133 {
3134 bfd *sub;
3135
3136 _bfd_elf_gc_mark_extra_sections (info, gc_mark_hook);
3137
3138 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
3139 {
3140 asection *o;
3141
3142 for (o = sub->sections; o != NULL; o = o->next)
3143 if (strcmp (o->name, ".csky_stack_size") == 0)
3144 o->gc_mark = 1;
3145 }
3146
3147 return true;
3148 }
3149
3150 /* The linker repeatedly calls this function for each input section,
3151 in the order that input sections are linked into output sections.
3152 Build lists of input sections to determine groupings between which
3153 we may insert linker stubs. */
3154
3155 void
3156 elf32_csky_next_input_section (struct bfd_link_info *info,
3157 asection *isec)
3158 {
3159 struct csky_elf_link_hash_table *htab = csky_elf_hash_table (info);
3160 if (htab == NULL)
3161 return;
3162 if (isec->output_section->index <= htab->top_index)
3163 {
3164 asection **list = htab->input_list + isec->output_section->index;
3165
3166 if (*list != bfd_abs_section_ptr)
3167 {
3168 /* Steal the link_sec pointer for our list. */
3169 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
3170 /* This happens to make the list in reverse order,
3171 which we reverse later in group_sections. */
3172 PREV_SEC (isec) = *list;
3173 *list = isec;
3174 }
3175 }
3176 }
3177
3178 /* See whether we can group stub sections together. Grouping stub
3179 sections may result in fewer stubs. More importantly, we need to
3180 put all .init* and .fini* stubs at the end of the .init or
3181 .fini output sections respectively, because glibc splits the
3182 _init and _fini functions into multiple parts. Putting a stub in
3183 the middle of a function is not a good idea. */
3184
3185 static void
3186 group_sections (struct csky_elf_link_hash_table *htab,
3187 bfd_size_type stub_group_size,
3188 bool stubs_always_after_branch)
3189 {
3190 asection **list = htab->input_list;
3191
3192 do
3193 {
3194 asection *tail = *list;
3195 asection *head;
3196
3197 if (tail == bfd_abs_section_ptr)
3198 continue;
3199
3200 /* Reverse the list: we must avoid placing stubs at the
3201 beginning of the section because the beginning of the text
3202 section may be required for an interrupt vector in bare metal
3203 code. */
3204 #define NEXT_SEC PREV_SEC
3205 head = NULL;
3206 while (tail != NULL)
3207 {
3208 /* Pop from tail. */
3209 asection *item = tail;
3210 tail = PREV_SEC (item);
3211
3212 /* Push on head. */
3213 NEXT_SEC (item) = head;
3214 head = item;
3215 }
3216
3217 while (head != NULL)
3218 {
3219 asection *curr;
3220 asection *next;
3221 bfd_vma stub_group_start = head->output_offset;
3222 bfd_vma end_of_next;
3223
3224 curr = head;
3225 while (NEXT_SEC (curr) != NULL)
3226 {
3227 next = NEXT_SEC (curr);
3228 end_of_next = next->output_offset + next->size;
3229 if (end_of_next - stub_group_start >= stub_group_size)
3230 /* End of NEXT is too far from start, so stop. */
3231 break;
3232 curr = next;
3233 }
3234
3235 /* OK, the size from the start to the start of CURR is less
3236 * than stub_group_size and thus can be handled by one stub
3237 * section. (Or the head section is itself larger than
3238 * stub_group_size, in which case we may be toast.)
3239 * We should really be keeping track of the total size of
3240 * stubs added here, as stubs contribute to the final output
3241 * section size. */
3242 do
3243 {
3244 next = NEXT_SEC (head);
3245 /* Set up this stub group. */
3246 htab->stub_group[head->id].link_sec = curr;
3247 }
3248 while (head != curr && (head = next) != NULL);
3249
3250 /* But wait, there's more! Input sections up to stub_group_size
3251 * bytes after the stub section can be handled by it too. */
3252 if (!stubs_always_after_branch)
3253 {
3254 stub_group_start = curr->output_offset + curr->size;
3255
3256 while (next != NULL)
3257 {
3258 end_of_next = next->output_offset + next->size;
3259 if (end_of_next - stub_group_start >= stub_group_size)
3260 /* End of NEXT is too far from stubs, so stop. */
3261 break;
3262 /* Add NEXT to the stub group. */
3263 head = next;
3264 next = NEXT_SEC (head);
3265 htab->stub_group[head->id].link_sec = curr;
3266 }
3267 }
3268 head = next;
3269 }
3270 }
3271 while (list++ != htab->input_list + htab->top_index);
3272
3273 free (htab->input_list);
3274 #undef PREV_SEC
3275 #undef NEXT_SEC
3276 }
3277
3278 /* If the symbol referenced by bsr is defined in shared object file,
3279 or it is a weak symbol and we aim to create shared object file,
3280 we must create a stub for this bsr. */
3281
3282 static bool
3283 sym_must_create_stub (struct elf_link_hash_entry *h,
3284 struct bfd_link_info *info)
3285 {
3286 if (h != NULL
3287 && ((h->def_dynamic && !h->def_regular)
3288 || (bfd_link_pic (info) && h->root.type == bfd_link_hash_defweak)))
3289 return true;
3290 else
3291 return false;
3292 }
3293
3294 /* Calculate the template, template size and instruction size for a stub.
3295 Return value is the instruction size. */
3296
3297 static unsigned int
3298 find_stub_size_and_template (enum elf32_csky_stub_type stub_type,
3299 const insn_sequence **stub_template,
3300 int *stub_template_size)
3301 {
3302 const insn_sequence *template_sequence = NULL;
3303 int template_size = 0;
3304 int i;
3305 unsigned int size;
3306
3307 template_sequence = stub_definitions[stub_type].template_sequence;
3308 template_size = stub_definitions[stub_type].template_size;
3309
3310 size = 0;
3311 for (i = 0; i < template_size; i++)
3312 {
3313 switch (template_sequence[i].type)
3314 {
3315 case INSN16:
3316 size += 2;
3317 break;
3318
3319 case INSN32:
3320 case DATA_TYPE:
3321 size += 4;
3322 break;
3323
3324 default:
3325 BFD_FAIL ();
3326 return false;
3327 }
3328 }
3329
3330 if (stub_template)
3331 *stub_template = template_sequence;
3332 if (stub_template_size)
3333 *stub_template_size = template_size;
3334
3335 return size;
3336 }
3337
3338 /* As above, but don't actually build the stub. Just bump offset so
3339 we know stub section sizes. */
3340
3341 static bool
3342 csky_size_one_stub (struct bfd_hash_entry *gen_entry,
3343 void * in_arg ATTRIBUTE_UNUSED)
3344 {
3345 struct elf32_csky_stub_hash_entry *stub_entry;
3346 const insn_sequence *template_sequence = NULL;
3347 int template_size = 0;
3348 int size = 0;
3349
3350 /* Massage our args to the form they really have. */
3351 stub_entry = (struct elf32_csky_stub_hash_entry *) gen_entry;
3352
3353 BFD_ASSERT (stub_entry->stub_type > csky_stub_none
3354 && stub_entry->stub_type < ARRAY_SIZE (stub_definitions));
3355 size = find_stub_size_and_template (stub_entry->stub_type,
3356 &template_sequence, &template_size);
3357 stub_entry->stub_size = size;
3358 stub_entry->stub_template = template_sequence;
3359 stub_entry->stub_template_size = template_size;
3360
3361 size = (size + 7) & ~7;
3362 stub_entry->stub_sec->size += size;
3363 return true;
3364 }
3365
3366 /* Add a new stub entry to the stub hash. Not all fields of the new
3367 stub entry are initialised. */
3368
3369 static struct elf32_csky_stub_hash_entry *
3370 elf32_csky_add_stub (const char *stub_name,
3371 asection *section,
3372 struct csky_elf_link_hash_table *htab)
3373 {
3374 asection *link_sec;
3375 asection *stub_sec;
3376 struct elf32_csky_stub_hash_entry *stub_entry;
3377
3378 stub_sec = elf32_csky_create_or_find_stub_sec (&link_sec, section, htab);
3379 if (stub_sec == NULL)
3380 return NULL;
3381
3382 /* Enter this entry into the linker stub hash table. */
3383 stub_entry = csky_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3384 true, false);
3385 if (stub_entry == NULL)
3386 {
3387 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
3388 section->owner, stub_name);
3389 return NULL;
3390 }
3391
3392 stub_entry->stub_sec = stub_sec;
3393 stub_entry->stub_offset = 0;
3394 stub_entry->id_sec = link_sec;
3395
3396 return stub_entry;
3397 }
3398
3399 /* Determine and set the size of the stub section for a final link.
3400 The basic idea here is to examine all the relocations looking for
3401 PC-relative calls to a target that is unreachable with a "bsr"
3402 instruction. */
3403
3404 bool
3405 elf32_csky_size_stubs (bfd *output_bfd,
3406 bfd *stub_bfd,
3407 struct bfd_link_info *info,
3408 bfd_signed_vma group_size,
3409 asection *(*add_stub_section) (const char*, asection*),
3410 void (*layout_sections_again) (void))
3411 {
3412 bfd_size_type stub_group_size;
3413 bool stubs_always_after_branch;
3414 struct csky_elf_link_hash_table *htab = csky_elf_hash_table (info);
3415
3416 if (htab == NULL)
3417 return false;
3418
3419 /* Propagate mach to stub bfd, because it may not have been
3420 finalized when we created stub_bfd. */
3421 bfd_set_arch_mach (stub_bfd, bfd_get_arch (output_bfd),
3422 bfd_get_mach (output_bfd));
3423
3424 /* Stash our params away. */
3425 htab->stub_bfd = stub_bfd;
3426 htab->add_stub_section = add_stub_section;
3427 htab->layout_sections_again = layout_sections_again;
3428 stubs_always_after_branch = group_size < 0;
3429
3430 if (group_size < 0)
3431 stub_group_size = -group_size;
3432 else
3433 stub_group_size = group_size;
3434
3435 if (stub_group_size == 1)
3436 /* The 'bsr' range in abiv2 is +-64MB has to be used as the
3437 default maximum size.
3438 This value is 128K less than that, which allows for 131072
3439 byte stubs. If we exceed that, then we will fail to link.
3440 The user will have to relink with an explicit group size
3441 option. */
3442 stub_group_size = 66977792;
3443
3444 group_sections (htab, stub_group_size, stubs_always_after_branch);
3445
3446 while (1)
3447 {
3448 bfd *input_bfd;
3449 unsigned int bfd_indx;
3450 asection *stub_sec;
3451 bool stub_changed = false;
3452
3453 for (input_bfd = info->input_bfds, bfd_indx = 0;
3454 input_bfd != NULL;
3455 input_bfd = input_bfd->link.next, bfd_indx++)
3456 {
3457 Elf_Internal_Shdr *symtab_hdr;
3458 asection *section;
3459 Elf_Internal_Sym *local_syms = NULL;
3460
3461 /* We'll need the symbol table in a second. */
3462 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3463 if (symtab_hdr->sh_info == 0)
3464 continue;
3465
3466 /* Walk over each section attached to the input bfd. */
3467 for (section = input_bfd->sections;
3468 section != NULL;
3469 section = section->next)
3470 {
3471 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
3472
3473 /* If there aren't any relocs, then there's nothing more
3474 * to do. */
3475 if ((section->flags & SEC_RELOC) == 0
3476 || section->reloc_count == 0
3477 || (section->flags & SEC_CODE) == 0)
3478 continue;
3479
3480 /* If this section is a link-once section that will be
3481 discarded, then don't create any stubs. */
3482 if (section->output_section == NULL
3483 || section->output_section->owner != output_bfd)
3484 continue;
3485
3486 /* Get the relocs. */
3487 internal_relocs = _bfd_elf_link_read_relocs (input_bfd,
3488 section,
3489 NULL, NULL,
3490 info->keep_memory);
3491
3492 if (internal_relocs == NULL)
3493 goto error_ret_free_local;
3494
3495 /* Now examine each relocation. */
3496 irela = internal_relocs;
3497 irelaend = irela + section->reloc_count;
3498 for (; irela < irelaend; irela++)
3499 {
3500 unsigned int r_type, r_indx;
3501 enum elf32_csky_stub_type stub_type;
3502 struct elf32_csky_stub_hash_entry *stub_entry;
3503 asection *sym_sec;
3504 bfd_vma sym_value;
3505 bfd_vma destination;
3506 struct csky_elf_link_hash_entry *hash;
3507 const char *sym_name;
3508 char *stub_name;
3509 const asection *id_sec;
3510 unsigned char st_type;
3511
3512 r_type = ELF32_R_TYPE (irela->r_info);
3513 r_indx = ELF32_R_SYM (irela->r_info);
3514 if (r_type >= (unsigned int) R_CKCORE_MAX)
3515 {
3516 bfd_set_error (bfd_error_bad_value);
3517 error_ret_free_internal:
3518 if (elf_section_data (section)->relocs == NULL)
3519 free (internal_relocs);
3520 goto error_ret_free_local;
3521 }
3522
3523 /* Only look for stubs on branch instructions. */
3524 if (r_type != (unsigned int) R_CKCORE_PCREL_IMM26BY2)
3525 continue;
3526 /* Now determine the call target, its name, value,
3527 section. */
3528 sym_sec = NULL;
3529 sym_value = 0;
3530 destination = 0;
3531 hash = NULL;
3532 sym_name = NULL;
3533 if (r_indx < symtab_hdr->sh_info)
3534 {
3535 /* It's a local symbol. */
3536 Elf_Internal_Sym *sym;
3537 Elf_Internal_Shdr *hdr;
3538 if (local_syms == NULL)
3539 local_syms =
3540 (Elf_Internal_Sym *) symtab_hdr->contents;
3541 if (local_syms == NULL)
3542 {
3543 local_syms =
3544 bfd_elf_get_elf_syms (input_bfd,
3545 symtab_hdr,
3546 symtab_hdr->sh_info,
3547 0, NULL, NULL, NULL);
3548 if (local_syms == NULL)
3549 goto error_ret_free_internal;
3550 }
3551 sym = local_syms + r_indx;
3552 hdr = elf_elfsections (input_bfd)[sym->st_shndx];
3553 sym_sec = hdr->bfd_section;
3554 if (!sym_sec)
3555 /* This is an undefined symbol. It can never
3556 be resolved. */
3557 continue;
3558 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3559 sym_value = sym->st_value;
3560 destination = (sym_value + irela->r_addend
3561 + sym_sec->output_offset
3562 + sym_sec->output_section->vma);
3563 st_type = ELF_ST_TYPE (sym->st_info);
3564 sym_name =
3565 bfd_elf_string_from_elf_section (input_bfd,
3566 symtab_hdr->sh_link,
3567 sym->st_name);
3568 }
3569 else
3570 {
3571 /* It's an external symbol. */
3572 int e_indx;
3573 e_indx = r_indx - symtab_hdr->sh_info;
3574 hash = ((struct csky_elf_link_hash_entry *)
3575 elf_sym_hashes (input_bfd)[e_indx]);
3576
3577 while (hash->elf.root.type == bfd_link_hash_indirect
3578 || hash->elf.root.type == bfd_link_hash_warning)
3579 hash = ((struct csky_elf_link_hash_entry *)
3580 hash->elf.root.u.i.link);
3581 if (hash->elf.root.type == bfd_link_hash_defined
3582 || hash->elf.root.type == bfd_link_hash_defweak)
3583 {
3584 sym_sec = hash->elf.root.u.def.section;
3585 sym_value = hash->elf.root.u.def.value;
3586
3587 struct csky_elf_link_hash_table *globals =
3588 csky_elf_hash_table (info);
3589 /* FIXME For a destination in a shared library. */
3590 if (globals->elf.splt != NULL && hash != NULL
3591 && hash->elf.plt.offset != (bfd_vma) -1)
3592 continue;
3593 else if (sym_sec->output_section != NULL)
3594 destination = (sym_value + irela->r_addend
3595 + sym_sec->output_offset
3596 + sym_sec->output_section->vma);
3597 }
3598 else if (hash->elf.root.type == bfd_link_hash_undefined
3599 || (hash->elf.root.type
3600 == bfd_link_hash_undefweak))
3601 /* FIXME For a destination in a shared library. */
3602 continue;
3603 else
3604 {
3605 bfd_set_error (bfd_error_bad_value);
3606 goto error_ret_free_internal;
3607 }
3608 st_type = ELF_ST_TYPE (hash->elf.type);
3609 sym_name = hash->elf.root.root.string;
3610 }
3611 do
3612 {
3613 /* Determine what (if any) linker stub is needed. */
3614 stub_type = csky_type_of_stub (info, section, irela,
3615 st_type, hash,
3616 destination, sym_sec,
3617 input_bfd, sym_name);
3618 if (stub_type == csky_stub_none)
3619 break;
3620
3621 /* Support for grouping stub sections. */
3622 id_sec = htab->stub_group[section->id].link_sec;
3623
3624 /* Get the name of this stub. */
3625 stub_name = elf32_csky_stub_name (id_sec, sym_sec, hash,
3626 irela);
3627 if (!stub_name)
3628 goto error_ret_free_internal;
3629 /* We've either created a stub for this reloc already,
3630 or we are about to. */
3631 stub_entry
3632 = csky_stub_hash_lookup (&htab->stub_hash_table,
3633 stub_name,
3634 false, false);
3635 if (stub_entry != NULL)
3636 {
3637 /* The proper stub has already been created. */
3638 free (stub_name);
3639 stub_entry->target_value = sym_value;
3640 break;
3641 }
3642 stub_entry = elf32_csky_add_stub (stub_name, section,
3643 htab);
3644 if (stub_entry == NULL)
3645 {
3646 free (stub_name);
3647 goto error_ret_free_internal;
3648 }
3649 stub_entry->target_value = sym_value;
3650 stub_entry->target_section = sym_sec;
3651 stub_entry->stub_type = stub_type;
3652 stub_entry->h = hash;
3653 stub_entry->st_type = st_type;
3654
3655 if (sym_name == NULL)
3656 sym_name = "unnamed";
3657 stub_entry->output_name =
3658 bfd_alloc (htab->stub_bfd,
3659 (sizeof (STUB_ENTRY_NAME)
3660 + strlen (sym_name)));
3661 if (stub_entry->output_name == NULL)
3662 {
3663 free (stub_name);
3664 goto error_ret_free_internal;
3665 }
3666 sprintf (stub_entry->output_name, STUB_ENTRY_NAME,
3667 sym_name);
3668 stub_changed = true;
3669 }
3670 while (0);
3671 }
3672 /* We're done with the internal relocs, free them. */
3673 if (elf_section_data (section)->relocs == NULL)
3674 free (internal_relocs);
3675 }
3676 }
3677 if (!stub_changed)
3678 break;
3679 /* OK, we've added some stubs. Find out the new size of the
3680 stub sections. */
3681 for (stub_sec = htab->stub_bfd->sections;
3682 stub_sec != NULL;
3683 stub_sec = stub_sec->next)
3684 {
3685 /* Ignore non-stub sections. */
3686 if (!strstr (stub_sec->name, STUB_SUFFIX))
3687 continue;
3688 stub_sec->size = 0;
3689 }
3690 bfd_hash_traverse (&htab->stub_hash_table, csky_size_one_stub, htab);
3691 /* Ask the linker to do its stuff. */
3692 (*htab->layout_sections_again) ();
3693 }
3694
3695 return true;
3696 error_ret_free_local:
3697 return false;
3698 }
3699
3700 static bool
3701 csky_build_one_stub (struct bfd_hash_entry *gen_entry,
3702 void * in_arg)
3703 {
3704 #define MAXRELOCS 2
3705 struct elf32_csky_stub_hash_entry *stub_entry;
3706 struct bfd_link_info *info;
3707 asection *stub_sec;
3708 bfd *stub_bfd;
3709 bfd_byte *loc;
3710 bfd_vma sym_value;
3711 int template_size;
3712 int size;
3713 const insn_sequence *template_sequence;
3714 int i;
3715 struct csky_elf_link_hash_table * globals;
3716 int stub_reloc_idx[MAXRELOCS] = {-1, -1};
3717 int stub_reloc_offset[MAXRELOCS] = {0, 0};
3718 int nrelocs = 0;
3719 struct elf_link_hash_entry *h = NULL;
3720
3721 /* Massage our args to the form they really have. */
3722 stub_entry = (struct elf32_csky_stub_hash_entry *)gen_entry;
3723 info = (struct bfd_link_info *) in_arg;
3724
3725 /* Fail if the target section could not be assigned to an output
3726 section. The user should fix his linker script. */
3727 if (stub_entry->target_section->output_section == NULL
3728 && info->non_contiguous_regions)
3729 info->callbacks->einfo (_("%F%P: Could not assign `%pA' to an output section. "
3730 "Retry without --enable-non-contiguous-regions.\n"),
3731 stub_entry->target_section);
3732
3733 globals = csky_elf_hash_table (info);
3734 if (globals == NULL)
3735 return false;
3736 stub_sec = stub_entry->stub_sec;
3737
3738 /* Make a note of the offset within the stubs for this entry. */
3739 stub_entry->stub_offset = stub_sec->size;
3740 loc = stub_sec->contents + stub_entry->stub_offset;
3741
3742 stub_bfd = stub_sec->owner;
3743
3744 /* This is the address of the stub destination. */
3745 h = &stub_entry->h->elf;
3746 if (sym_must_create_stub (h, info)
3747 && !(bfd_link_pic (info)
3748 && h->root.type == bfd_link_hash_defweak
3749 && h->def_regular
3750 && !h->def_dynamic))
3751 sym_value = 0;
3752 else
3753 sym_value = (stub_entry->target_value
3754 + stub_entry->target_section->output_offset
3755 + stub_entry->target_section->output_section->vma);
3756
3757 template_sequence = stub_entry->stub_template;
3758 template_size = stub_entry->stub_template_size;
3759
3760 size = 0;
3761 for (i = 0; i < template_size; i++)
3762 switch (template_sequence[i].type)
3763 {
3764 case INSN16:
3765 bfd_put_16 (stub_bfd, (bfd_vma) template_sequence[i].data,
3766 loc + size);
3767 size += 2;
3768 break;
3769 case INSN32:
3770 csky_put_insn_32 (stub_bfd, (bfd_vma) template_sequence[i].data,
3771 loc + size);
3772 size += 4;
3773 break;
3774 case DATA_TYPE:
3775 bfd_put_32 (stub_bfd, (bfd_vma) template_sequence[i].data,
3776 loc + size);
3777 stub_reloc_idx[nrelocs] = i;
3778 stub_reloc_offset[nrelocs++] = size;
3779 size += 4;
3780 break;
3781 default:
3782 BFD_FAIL ();
3783 return false;
3784 }
3785 stub_sec->size += size;
3786
3787 /* Stub size has already been computed in csky_size_one_stub. Check
3788 consistency. */
3789 BFD_ASSERT (size == stub_entry->stub_size);
3790
3791 /* Assume there is at least one and at most MAXRELOCS entries to relocate
3792 in each stub. */
3793 BFD_ASSERT (nrelocs != 0 && nrelocs <= MAXRELOCS);
3794
3795 for (i = 0; i < nrelocs; i++)
3796 {
3797 if (sym_must_create_stub (h, info))
3798 {
3799 Elf_Internal_Rela outrel;
3800 asection * sreloc = globals->elf.srelgot;
3801
3802 outrel.r_offset = stub_entry->stub_offset + stub_reloc_offset[i];
3803 outrel.r_info =
3804 ELF32_R_INFO (h->dynindx,
3805 template_sequence[stub_reloc_idx[i]].r_type);
3806 outrel.r_addend = template_sequence[stub_reloc_idx[i]].reloc_addend;
3807
3808 loc = sreloc->contents;
3809 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
3810
3811 if (loc != NULL)
3812 bfd_elf32_swap_reloca_out (info->output_bfd, &outrel, loc);
3813 }
3814 _bfd_final_link_relocate (elf32_csky_howto_from_type
3815 (template_sequence[stub_reloc_idx[i]].r_type),
3816 stub_bfd, stub_sec, stub_sec->contents,
3817 stub_entry->stub_offset + stub_reloc_offset[i],
3818 sym_value + stub_entry->target_addend,
3819 template_sequence[stub_reloc_idx[i]].reloc_addend);
3820 }
3821
3822 return true;
3823 #undef MAXRELOCS
3824 }
3825
3826 /* Build all the stubs associated with the current output file. The
3827 stubs are kept in a hash table attached to the main linker hash
3828 table. We also set up the .plt entries for statically linked PIC
3829 functions here. This function is called via arm_elf_finish in the
3830 linker. */
3831
3832 bool
3833 elf32_csky_build_stubs (struct bfd_link_info *info)
3834 {
3835 asection *stub_sec;
3836 struct bfd_hash_table *table;
3837 struct csky_elf_link_hash_table *htab;
3838
3839 htab = csky_elf_hash_table (info);
3840
3841 if (htab == NULL)
3842 return false;
3843
3844 for (stub_sec = htab->stub_bfd->sections;
3845 stub_sec != NULL;
3846 stub_sec = stub_sec->next)
3847 {
3848 bfd_size_type size;
3849
3850 /* Ignore non-stub sections. */
3851 if (!strstr (stub_sec->name, STUB_SUFFIX))
3852 continue;
3853
3854 /* Allocate memory to hold the linker stubs. */
3855 size = stub_sec->size;
3856 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
3857 if (stub_sec->contents == NULL && size != 0)
3858 return false;
3859 stub_sec->alloced = 1;
3860 stub_sec->size = 0;
3861 }
3862
3863 /* Build the stubs as directed by the stub hash table. */
3864 table = &htab->stub_hash_table;
3865 bfd_hash_traverse (table, csky_build_one_stub, info);
3866
3867 return true;
3868 }
3869
3870 /* Set up various things so that we can make a list of input sections
3871 for each output section included in the link. Returns -1 on error,
3872 0 when no stubs will be needed, and 1 on success. */
3873
3874 int
3875 elf32_csky_setup_section_lists (bfd *output_bfd,
3876 struct bfd_link_info *info)
3877 {
3878 bfd *input_bfd;
3879 unsigned int bfd_count;
3880 unsigned int top_id, top_index;
3881 asection *section;
3882 asection **input_list, **list;
3883 size_t amt;
3884 struct csky_elf_link_hash_table *htab = csky_elf_hash_table (info);
3885
3886 if (!htab)
3887 return 0;
3888
3889 /* Count the number of input BFDs and find the top input section id. */
3890 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3891 input_bfd != NULL;
3892 input_bfd = input_bfd->link.next)
3893 {
3894 bfd_count += 1;
3895 for (section = input_bfd->sections;
3896 section != NULL;
3897 section = section->next)
3898 if (top_id < section->id)
3899 top_id = section->id;
3900 }
3901 htab->bfd_count = bfd_count;
3902 amt = sizeof (struct map_stub) * (top_id + 1);
3903 htab->stub_group = bfd_zmalloc (amt);
3904 if (htab->stub_group == NULL)
3905 return -1;
3906
3907 /* We can't use output_bfd->section_count here to find the top output
3908 section index as some sections may have been removed, and
3909 _bfd_strip_section_from_output doesn't renumber the indices. */
3910 for (section = output_bfd->sections, top_index = 0;
3911 section != NULL;
3912 section = section->next)
3913 if (top_index < section->index)
3914 top_index = section->index;
3915 htab->top_index = top_index;
3916 amt = sizeof (asection *) * (top_index + 1);
3917 input_list = bfd_malloc (amt);
3918 htab->input_list = input_list;
3919 if (input_list == NULL)
3920 return -1;
3921 /* For sections we aren't interested in, mark their entries with a
3922 value we can check later. */
3923 list = input_list + top_index;
3924 do
3925 *list = bfd_abs_section_ptr;
3926 while (list-- != input_list);
3927 for (section = output_bfd->sections;
3928 section != NULL;
3929 section = section->next)
3930 if ((section->flags & SEC_CODE) != 0)
3931 input_list[section->index] = NULL;
3932
3933 return 1;
3934 }
3935
3936 static bfd_reloc_status_type
3937 csky_relocate_contents (reloc_howto_type *howto,
3938 bfd *input_bfd,
3939 bfd_vma relocation,
3940 bfd_byte *location)
3941 {
3942 int size;
3943 bfd_vma x = 0;
3944 bfd_reloc_status_type flag;
3945 unsigned int rightshift = howto->rightshift;
3946 unsigned int bitpos = howto->bitpos;
3947
3948 if (howto->negate)
3949 relocation = -relocation;
3950
3951 /* FIXME: these macros should be defined at file head or head file head. */
3952 #define CSKY_INSN_ADDI_TO_SUBI 0x04000000
3953 #define CSKY_INSN_MOV_RTB 0xc41d4820 /* mov32 rx, r29, 0 */
3954 #define CSKY_INSN_MOV_RDB 0xc41c4820 /* mov32 rx, r28, 0 */
3955 #define CSKY_INSN_GET_ADDI_RZ(x) (((x) & 0x03e00000) >> 21)
3956 #define CSKY_INSN_SET_MOV_RZ(x) ((x) & 0x0000001f)
3957 #define CSKY_INSN_JSRI_TO_LRW 0xea9a0000
3958 #define CSKY_INSN_JSR_R26 0xe8fa0000
3959
3960 /* Get the value we are going to relocate. */
3961 size = bfd_get_reloc_size (howto);
3962 switch (size)
3963 {
3964 default:
3965 case 0:
3966 abort ();
3967 case 1:
3968 x = bfd_get_8 (input_bfd, location);
3969 break;
3970 case 2:
3971 x = bfd_get_16 (input_bfd, location);
3972 break;
3973 case 4:
3974 if (need_reverse_bits)
3975 {
3976 x = csky_get_insn_32 (input_bfd, location);
3977
3978 if (R_CKCORE_DOFFSET_LO16 == howto->type)
3979 {
3980 if ((bfd_signed_vma) relocation < 0)
3981 {
3982 x |= CSKY_INSN_ADDI_TO_SUBI;
3983 relocation = -relocation;
3984 }
3985 else if (0 == relocation)
3986 x = (CSKY_INSN_MOV_RDB |
3987 CSKY_INSN_SET_MOV_RZ (CSKY_INSN_GET_ADDI_RZ (x)));
3988 }
3989 else if (R_CKCORE_TOFFSET_LO16 == howto->type)
3990 {
3991 if ((bfd_signed_vma) relocation < 0)
3992 {
3993 x |= CSKY_INSN_ADDI_TO_SUBI;
3994 relocation = -relocation;
3995 }
3996 else if (0 == relocation)
3997 x = (CSKY_INSN_MOV_RTB |
3998 CSKY_INSN_SET_MOV_RZ (CSKY_INSN_GET_ADDI_RZ (x)));
3999 }
4000 }
4001 else
4002 x = bfd_get_32 (input_bfd, location);
4003 break;
4004 }
4005 /* Check for overflow. FIXME: We may drop bits during the addition
4006 which we don't check for. We must either check at every single
4007 operation, which would be tedious, or we must do the computations
4008 in a type larger than bfd_vma, which would be inefficient. */
4009 flag = bfd_reloc_ok;
4010 if (howto->complain_on_overflow != complain_overflow_dont)
4011 {
4012 bfd_vma addrmask;
4013 bfd_vma fieldmask;
4014 bfd_vma signmask;
4015 bfd_vma ss;
4016 bfd_vma a;
4017 bfd_vma b;
4018 bfd_vma sum;
4019 /* Get the values to be added together. For signed and unsigned
4020 relocations, we assume that all values should be truncated to
4021 the size of an address. For bitfields, all the bits matter.
4022 See also bfd_check_overflow. */
4023 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
4024 fieldmask = N_ONES (howto->bitsize);
4025 signmask = ~fieldmask;
4026 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
4027 a = (relocation & addrmask) >> rightshift;
4028 if (read_content_substitute)
4029 x = read_content_substitute;
4030 b = (x & howto->src_mask & addrmask) >> bitpos;
4031
4032 switch (howto->complain_on_overflow)
4033 {
4034 case complain_overflow_signed:
4035 /* If any sign bits are set, all sign bits must be set.
4036 That is, A must be a valid negative address after
4037 shifting. */
4038 signmask = ~(fieldmask >> 1);
4039 /* Fall through. */
4040
4041 case complain_overflow_bitfield:
4042 /* Much like the signed check, but for a field one bit
4043 wider. We allow a bitfield to represent numbers in the
4044 range -2**n to 2**n-1, where n is the number of bits in the
4045 field. Note that when bfd_vma is 32 bits, a 32-bit reloc
4046 can't overflow, which is exactly what we want. */
4047 ss = a & signmask;
4048 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
4049 flag = bfd_reloc_overflow;
4050 /* We only need this next bit of code if the sign bit of B
4051 is below the sign bit of A. This would only happen if
4052 SRC_MASK had fewer bits than BITSIZE. Note that if
4053 SRC_MASK has more bits than BITSIZE, we can get into
4054 trouble; we would need to verify that B is in range, as
4055 we do for A above. */
4056 ss = ((~howto->src_mask) >> 1) & howto->src_mask;
4057 ss >>= bitpos;
4058
4059 /* Set all the bits above the sign bit. */
4060 b = (b ^ ss) - ss;
4061
4062 /* Now we can do the addition. */
4063 sum = a + b;
4064
4065 /* See if the result has the correct sign. Bits above the
4066 sign bit are junk now; ignore them. If the sum is
4067 positive, make sure we did not have all negative inputs;
4068 if the sum is negative, make sure we did not have all
4069 positive inputs. The test below looks only at the sign
4070 bits, and it really just
4071 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
4072
4073 We mask with addrmask here to explicitly allow an address
4074 wrap-around. The Linux kernel relies on it, and it is
4075 the only way to write assembler code which can run when
4076 loaded at a location 0x80000000 away from the location at
4077 which it is linked. */
4078
4079 if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
4080 flag = bfd_reloc_overflow;
4081 break;
4082 case complain_overflow_unsigned:
4083 /* Checking for an unsigned overflow is relatively easy:
4084 trim the addresses and add, and trim the result as well.
4085 Overflow is normally indicated when the result does not
4086 fit in the field. However, we also need to consider the
4087 case when, e.g., fieldmask is 0x7fffffff or smaller, an
4088 input is 0x80000000, and bfd_vma is only 32 bits; then we
4089 will get sum == 0, but there is an overflow, since the
4090 inputs did not fit in the field. Instead of doing a
4091 separate test, we can check for this by or-ing in the
4092 operands when testing for the sum overflowing its final
4093 field. */
4094 sum = (a + b) & addrmask;
4095 if ((a | b | sum) & signmask)
4096 flag = bfd_reloc_overflow;
4097 break;
4098 default:
4099 abort ();
4100 }
4101
4102 }
4103 /* Put RELOCATION in the right bits. */
4104 relocation >>= rightshift;
4105
4106 if ((howto->type == R_CKCORE_DOFFSET_LO16
4107 || howto->type == R_CKCORE_TOFFSET_LO16)
4108 && relocation == 0)
4109 /* Do nothing lsli32 rx, rz, 0. */
4110 ;
4111 else
4112 {
4113 /* Fir V1, all this relocation must be x -1. */
4114 if (howto->type == R_CKCORE_PCREL_IMM11BY2
4115 || howto->type == R_CKCORE_PCREL_JSR_IMM11BY2
4116 || howto->type == R_CKCORE_DOFFSET_LO16
4117 || howto->type == R_CKCORE_TOFFSET_LO16)
4118 relocation -= 1;
4119 else if (howto->type == R_CKCORE_PCREL_IMM7BY4)
4120 relocation = (relocation & 0x1f) + ((relocation << 3) & 0x300);
4121 else if (howto->type == R_CKCORE_PCREL_FLRW_IMM8BY4)
4122 relocation
4123 = ((relocation << 4) & 0xf0) + ((relocation << 17) & 0x1e00000);
4124 else if (howto->type == R_CKCORE_NOJSRI)
4125 {
4126 x = (x & howto->dst_mask) | CSKY_INSN_JSRI_TO_LRW;
4127 relocation = 0;
4128 csky_put_insn_32 (input_bfd, CSKY_INSN_JSR_R26, location + 4);
4129 }
4130
4131 relocation <<= bitpos;
4132 /* Add RELOCATION to the right bits of X. */
4133 x = ((x & ~howto->dst_mask)
4134 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
4135 }
4136 /* Put the relocated value back in the object file. */
4137 switch (size)
4138 {
4139 default:
4140 abort ();
4141 case 1:
4142 bfd_put_8 (input_bfd, x, location);
4143 break;
4144 case 2:
4145 bfd_put_16 (input_bfd, x, location);
4146 break;
4147 case 4:
4148 if (need_reverse_bits)
4149 csky_put_insn_32 (input_bfd, x, location);
4150 else
4151 bfd_put_32 (input_bfd, x, location);
4152 break;
4153 }
4154 return flag;
4155 }
4156
4157 /* Look up an entry in the stub hash. Stub entries are cached because
4158 creating the stub name takes a bit of time. */
4159
4160 static struct elf32_csky_stub_hash_entry *
4161 elf32_csky_get_stub_entry (const asection *input_section,
4162 const asection *sym_sec,
4163 struct elf_link_hash_entry *hash,
4164 const Elf_Internal_Rela *rel,
4165 struct csky_elf_link_hash_table *htab)
4166 {
4167 struct elf32_csky_stub_hash_entry *stub_entry;
4168 struct csky_elf_link_hash_entry *h
4169 = (struct csky_elf_link_hash_entry *) hash;
4170 const asection *id_sec;
4171
4172 if ((input_section->flags & SEC_CODE) == 0)
4173 return NULL;
4174
4175 /* If this input section is part of a group of sections sharing one
4176 stub section, then use the id of the first section in the group.
4177 Stub names need to include a section id, as there may well be
4178 more than one stub used to reach say, printf, and we need to
4179 distinguish between them. */
4180 id_sec = htab->stub_group[input_section->id].link_sec;
4181 if (h != NULL && h->stub_cache != NULL
4182 && h->stub_cache->h == h && h->stub_cache->id_sec == id_sec)
4183 stub_entry = h->stub_cache;
4184 else
4185 {
4186 char *stub_name;
4187 stub_name = elf32_csky_stub_name (id_sec, sym_sec, h, rel);
4188 if (stub_name == NULL)
4189 return NULL;
4190 stub_entry = csky_stub_hash_lookup (&htab->stub_hash_table,
4191 stub_name, false, false);
4192 if (h != NULL)
4193 h->stub_cache = stub_entry;
4194 free (stub_name);
4195 }
4196
4197 return stub_entry;
4198 }
4199
4200 static bfd_reloc_status_type
4201 csky_final_link_relocate (reloc_howto_type *howto,
4202 bfd *input_bfd,
4203 asection *input_section,
4204 bfd_byte *contents,
4205 bfd_vma address,
4206 bfd_vma value,
4207 bfd_vma addend)
4208 {
4209 bfd_vma relocation;
4210
4211 /* Sanity check the address. */
4212 if (address > bfd_get_section_limit (input_bfd, input_section))
4213 return bfd_reloc_outofrange;
4214
4215 /* This function assumes that we are dealing with a basic relocation
4216 against a symbol. We want to compute the value of the symbol to
4217 relocate to. This is just VALUE, the value of the symbol,
4218 plus ADDEND, any addend associated with the reloc. */
4219 relocation = value + addend;
4220
4221 /* If the relocation is PC relative, we want to set RELOCATION to
4222 the distance between the symbol (currently in RELOCATION) and the
4223 location we are relocating. Some targets (e.g., i386-aout)
4224 arrange for the contents of the section to be the negative of the
4225 offset of the location within the section; for such targets
4226 pcrel_offset is FALSE. Other targets (e.g., m88kbcs or ELF)
4227 simply leave the contents of the section as zero; for such
4228 targets pcrel_offset is TRUE. If pcrel_offset is FALSE we do not
4229 need to subtract out the offset of the location within the
4230 section (which is just ADDRESS). */
4231 if (howto->pc_relative)
4232 {
4233 relocation -= (input_section->output_section->vma
4234 + input_section->output_offset);
4235 if (howto->pcrel_offset)
4236 relocation -= address;
4237 }
4238
4239 return csky_relocate_contents (howto, input_bfd, relocation,
4240 contents + address);
4241
4242 }
4243
4244 /* Return the base VMA address which should be subtracted from real addresses
4245 when resolving @dtpoff relocation.
4246 This is PT_TLS segment p_vaddr. */
4247
4248 static bfd_vma
4249 dtpoff_base (struct bfd_link_info *info)
4250 {
4251 /* If tls_sec is NULL, we should have signalled an error already. */
4252 if (elf_hash_table (info)->tls_sec == NULL)
4253 return 0;
4254 return elf_hash_table (info)->tls_sec->vma;
4255 }
4256
4257 /* Return the relocation value for @tpoff relocation
4258 if STT_TLS virtual address is ADDRESS. */
4259
4260 static bfd_vma
4261 tpoff (struct bfd_link_info *info, bfd_vma address)
4262 {
4263 struct elf_link_hash_table *htab = elf_hash_table (info);
4264 bfd_vma base;
4265
4266 /* If tls_sec is NULL, we should have signalled an error already. */
4267 if (htab->tls_sec == NULL)
4268 return 0;
4269 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
4270 return address - htab->tls_sec->vma + base;
4271 }
4272
4273 /* Relocate a csky section. */
4274
4275 static int
4276 csky_elf_relocate_section (bfd * output_bfd,
4277 struct bfd_link_info * info,
4278 bfd * input_bfd,
4279 asection * input_section,
4280 bfd_byte * contents,
4281 Elf_Internal_Rela * relocs,
4282 Elf_Internal_Sym * local_syms,
4283 asection ** local_sections)
4284 {
4285 Elf_Internal_Shdr *symtab_hdr;
4286 struct elf_link_hash_entry **sym_hashes;
4287 Elf_Internal_Rela *rel;
4288 Elf_Internal_Rela *relend;
4289 const char *name;
4290 bool ret = true;
4291 struct csky_elf_link_hash_table * htab;
4292 bfd_vma *local_got_offsets = elf_local_got_offsets (input_bfd);
4293
4294 htab = csky_elf_hash_table (info);
4295 if (htab == NULL)
4296 return false;
4297
4298 symtab_hdr = & elf_symtab_hdr (input_bfd);
4299 sym_hashes = elf_sym_hashes (input_bfd);
4300
4301 rel = relocs;
4302 relend = relocs + input_section->reloc_count;
4303 for (; rel < relend; rel++)
4304 {
4305 enum elf_csky_reloc_type r_type
4306 = (enum elf_csky_reloc_type) ELF32_R_TYPE (rel->r_info);
4307 unsigned long r_symndx;
4308 reloc_howto_type *howto;
4309 Elf_Internal_Sym *sym;
4310 asection *sec;
4311 bfd_vma relocation;
4312 bfd_vma off;
4313 struct elf_link_hash_entry * h;
4314 bfd_vma addend = (bfd_vma)rel->r_addend;
4315 bfd_reloc_status_type r = bfd_reloc_ok;
4316 bool unresolved_reloc = false;
4317 int do_final_relocate = true;
4318 bool relative_reloc = false;
4319 bfd_signed_vma disp;
4320
4321 /* Ignore these relocation types:
4322 R_CKCORE_GNU_VTINHERIT, R_CKCORE_GNU_VTENTRY. */
4323 if (r_type == R_CKCORE_GNU_VTINHERIT || r_type == R_CKCORE_GNU_VTENTRY)
4324 continue;
4325
4326 if ((unsigned) r_type >= (unsigned) R_CKCORE_MAX)
4327 {
4328 /* The r_type is error, not support it. */
4329 /* xgettext:c-format */
4330 _bfd_error_handler (_("%pB: unsupported relocation type: %#x"),
4331 input_bfd, r_type);
4332 bfd_set_error (bfd_error_bad_value);
4333 ret = false;
4334 continue;
4335 }
4336
4337 howto = &csky_elf_howto_table[(int) r_type];
4338
4339 r_symndx = ELF32_R_SYM(rel->r_info);
4340 h = NULL;
4341 sym = NULL;
4342 sec = NULL;
4343 unresolved_reloc = false;
4344
4345 if (r_symndx < symtab_hdr->sh_info)
4346 {
4347 /* Get symbol table entry. */
4348 sym = local_syms + r_symndx;
4349 sec = local_sections[r_symndx];
4350 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4351 addend = (bfd_vma)rel->r_addend;
4352 }
4353 else
4354 {
4355 bool warned, ignored;
4356
4357 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4358 r_symndx, symtab_hdr, sym_hashes,
4359 h, sec, relocation,
4360 unresolved_reloc, warned, ignored);
4361 }
4362
4363 if (sec != NULL && discarded_section (sec))
4364 {
4365 /* For relocs against symbols from removed linkonce sections,
4366 or sections discarded by a linker script, we just want the
4367 section contents zeroed. Avoid any special processing.
4368 And if the symbol is referenced in '.csky_stack_size' section,
4369 set the address to SEC_DISCARDED(0xffffffff). */
4370 #if 0
4371 /* The .csky_stack_size section is just for callgraph. */
4372 if (strcmp (input_section->name, ".csky_stack_size") == 0)
4373 {
4374 /* FIXME: it should define in head file. */
4375 #define SEC_DISCARDED 0xffffffff
4376 bfd_put_32 (input_bfd, SEC_DISCARDED, contents + rel->r_offset);
4377 rel->r_info = 0;
4378 rel->r_addend = 0;
4379 continue;
4380 }
4381 else
4382 #endif
4383 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4384 rel, 1, relend, howto, 0,
4385 contents);
4386 }
4387
4388 if (bfd_link_relocatable (info))
4389 continue;
4390
4391 read_content_substitute = 0;
4392
4393 /* Final link. */
4394 disp = (relocation
4395 + (bfd_signed_vma) addend
4396 - input_section->output_section->vma
4397 - input_section->output_offset
4398 - rel->r_offset);
4399 /* It is for ck8xx. */
4400 #define CSKY_INSN_BSR32 0xe0000000
4401 /* It is for ck5xx/ck6xx. */
4402 #define CSKY_INSN_BSR16 0xf800
4403 #define within_range(x, L) (-(1 << (L - 1)) < (x) && (x) < (1 << (L -1)) - 2)
4404 switch (howto->type)
4405 {
4406 case R_CKCORE_PCREL_IMM18BY2:
4407 /* When h is NULL, means the instruction written as
4408 grs rx, imm32
4409 if the highest bit is set, prevent the high 32bits
4410 turn to 0xffffffff when signed extern in 64bit
4411 host machine. */
4412 if (h == NULL && (addend & 0x80000000))
4413 addend &= 0xffffffff;
4414 break;
4415
4416 case R_CKCORE_PCREL32:
4417 break;
4418
4419 case R_CKCORE_GOT12:
4420 case R_CKCORE_PLT12:
4421 case R_CKCORE_GOT_HI16:
4422 case R_CKCORE_GOT_LO16:
4423 case R_CKCORE_PLT_HI16:
4424 case R_CKCORE_PLT_LO16:
4425 case R_CKCORE_GOT32:
4426 case R_CKCORE_GOT_IMM18BY4:
4427 /* Relocation is to the entry for this symbol in the global
4428 offset table. */
4429 BFD_ASSERT (htab->elf.sgot != NULL);
4430 if (h != NULL)
4431 {
4432 /* Global symbol is defined by other modules. */
4433 bool dyn;
4434 off = h->got.offset;
4435 dyn = htab->elf.dynamic_sections_created;
4436 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4437 bfd_link_pic (info), h)
4438 || (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info,h))
4439 || (ELF_ST_VISIBILITY(h->other)
4440 && h->root.type == bfd_link_hash_undefweak))
4441 {
4442 /* This is actually a static link, or it is a
4443 -Bsymbolic link and the symbol is defined
4444 locally, or the symbol was forced to be local
4445 because of a version file. We must initialize
4446 this entry in the global offset table. Since the
4447 offset must always be a multiple of 4, we use the
4448 least significant bit to record whether we have
4449 initialized it already.
4450 When doing a dynamic link, we create a .rela.dyn
4451 relocation entry to initialize the value. This
4452 is done in the finish_dynamic_symbol routine. FIXME */
4453 if (off & 1)
4454 off &= ~1;
4455 else
4456 {
4457 bfd_put_32 (output_bfd, relocation,
4458 htab->elf.sgot->contents + off);
4459 h->got.offset |= 1;
4460
4461 /* TRUE if relative relocation should be generated. GOT reference to
4462 global symbol in PIC will lead to dynamic symbol. It becomes a
4463 problem when "time" or "times" is defined as a variable in an
4464 executable, clashing with functions of the same name in libc. If a
4465 symbol isn't undefined weak symbol, don't make it dynamic in PIC and
4466 generate relative relocation. */
4467 #define GENERATE_RELATIVE_RELOC_P(INFO, H) \
4468 ((H)->dynindx == -1 \
4469 && !(H)->forced_local \
4470 && (H)->root.type != bfd_link_hash_undefweak \
4471 && bfd_link_pic (INFO))
4472
4473 if (GENERATE_RELATIVE_RELOC_P (info, h))
4474 /* If this symbol isn't dynamic
4475 in PIC, generate R_CKCORE_RELATIVE here. */
4476 relative_reloc = true;
4477 }
4478 }
4479 else
4480 unresolved_reloc = false;
4481 } /* End if h != NULL. */
4482 else
4483 {
4484 BFD_ASSERT (local_got_offsets != NULL);
4485 off = local_got_offsets[r_symndx];
4486
4487 /* The offset must always be a multiple of 4. We use
4488 the least significant bit to record whether we have
4489 already generated the necessary reloc. */
4490 if (off & 1)
4491 off &= ~1;
4492 else
4493 {
4494 bfd_put_32 (output_bfd, relocation,
4495 htab->elf.sgot->contents + off);
4496 local_got_offsets[r_symndx] |= 1;
4497 if (bfd_link_pic (info))
4498 relative_reloc = true;
4499 }
4500 }
4501 if (relative_reloc)
4502 {
4503 asection *srelgot;
4504 Elf_Internal_Rela outrel;
4505 bfd_byte *loc;
4506
4507 srelgot = htab->elf.srelgot;
4508 BFD_ASSERT (srelgot != NULL);
4509
4510 outrel.r_offset
4511 = (htab->elf.sgot->output_section->vma
4512 + htab->elf.sgot->output_offset + off);
4513 outrel.r_info = ELF32_R_INFO (0, R_CKCORE_RELATIVE);
4514 outrel.r_addend = relocation;
4515 loc = srelgot->contents;
4516 loc += (srelgot->reloc_count++ * sizeof (Elf32_External_Rela));
4517 if (loc != NULL)
4518 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4519 }
4520 relocation = htab->elf.sgot->output_offset + off;
4521 break;
4522
4523 case R_CKCORE_GOTOFF_IMM18:
4524 case R_CKCORE_GOTOFF:
4525 case R_CKCORE_GOTOFF_HI16:
4526 case R_CKCORE_GOTOFF_LO16:
4527 /* Relocation is relative to the start of the global offset
4528 table. */
4529 /* Note that sgot->output_offset is not involved in this
4530 calculation. We always want the start of .got. If we
4531 defined _GLOBAL_OFFSET_TABLE in a different way, as is
4532 permitted by the ABI, we might have to change this
4533 calculation. */
4534 relocation -= htab->elf.sgot->output_section->vma;
4535 break;
4536
4537 case R_CKCORE_GOTPC:
4538 case R_CKCORE_GOTPC_HI16:
4539 case R_CKCORE_GOTPC_LO16:
4540 /* Use global offset table as symbol value. */
4541 relocation = htab->elf.sgot->output_section->vma;
4542 addend = -addend;
4543 unresolved_reloc = false;
4544 break;
4545
4546 case R_CKCORE_DOFFSET_IMM18:
4547 case R_CKCORE_DOFFSET_IMM18BY2:
4548 case R_CKCORE_DOFFSET_IMM18BY4:
4549 {
4550 asection *sdata = bfd_get_section_by_name (output_bfd, ".data");
4551 relocation -= sdata->output_section->vma;
4552 }
4553 break;
4554
4555 case R_CKCORE_DOFFSET_LO16:
4556 {
4557 asection *sdata = bfd_get_section_by_name (output_bfd, ".data");
4558 relocation -= sdata->output_section->vma;
4559 }
4560 break;
4561
4562 case R_CKCORE_TOFFSET_LO16:
4563 {
4564 asection *stext = bfd_get_section_by_name (output_bfd, ".text");
4565 if (stext)
4566 relocation -= stext->output_section->vma;
4567 }
4568 break;
4569
4570 case R_CKCORE_PLT_IMM18BY4:
4571 case R_CKCORE_PLT32:
4572 /* Relocation is to the entry for this symbol in the
4573 procedure linkage table. */
4574
4575 /* Resolve a PLT32 reloc against a local symbol directly,
4576 without using the procedure linkage table. */
4577 if (h == NULL)
4578 break;
4579
4580 if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
4581 {
4582 /* We didn't make a PLT entry for this symbol. This
4583 happens when statically linking PIC code, or when
4584 using -Bsymbolic. */
4585 if (h->got.offset != (bfd_vma) -1)
4586 {
4587 bool dyn;
4588
4589 off = h->got.offset;
4590 dyn = htab->elf.dynamic_sections_created;
4591 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4592 bfd_link_pic (info), h)
4593 || (bfd_link_pic (info)
4594 && SYMBOL_REFERENCES_LOCAL (info, h))
4595 || (ELF_ST_VISIBILITY (h->other)
4596 && h->root.type == bfd_link_hash_undefweak))
4597 {
4598 /* This is actually a static link, or it is a
4599 -Bsymbolic link and the symbol is defined
4600 locally, or the symbol was forced to be local
4601 because of a version file. We must initialize
4602 this entry in the global offset table. Since the
4603 offset must always be a multiple of 4, we use the
4604 least significant bit to record whether we have
4605 initialized it already.
4606
4607 When doing a dynamic link, we create a .rela.dyn
4608 relocation entry to initialize the value. This
4609 is done in the finish_dynamic_symbol routine.
4610 FIXME! */
4611 if (off & 1)
4612 off &= ~1;
4613 else
4614 {
4615 h->got.offset |= 1;
4616 if (GENERATE_RELATIVE_RELOC_P (info, h))
4617 relative_reloc = true;
4618 }
4619 }
4620 bfd_put_32 (output_bfd, relocation,
4621 htab->elf.sgot->contents + off);
4622
4623 if (relative_reloc)
4624 {
4625 asection *srelgot;
4626 Elf_Internal_Rela outrel;
4627 bfd_byte *loc;
4628
4629 srelgot = htab->elf.srelgot;
4630 BFD_ASSERT (srelgot != NULL);
4631
4632 outrel.r_offset
4633 = (htab->elf.sgot->output_section->vma
4634 + htab->elf.sgot->output_offset + off);
4635 outrel.r_info = ELF32_R_INFO (0, R_CKCORE_RELATIVE);
4636 outrel.r_addend = relocation;
4637 loc = srelgot->contents;
4638 loc += (srelgot->reloc_count++
4639 * sizeof (Elf32_External_Rela));
4640 if (loc != NULL)
4641 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4642 }
4643 relocation = off + htab->elf.sgot->output_offset;
4644 }
4645 break;
4646 }
4647 /* The relocation is the got offset. */
4648 if (bfd_csky_abi (output_bfd) == CSKY_ABI_V2)
4649 relocation = (h->plt.offset / PLT_ENTRY_SIZE + 2) * 4;
4650 else
4651 relocation = (h->plt.offset / PLT_ENTRY_SIZE_P + 2) * 4;
4652 unresolved_reloc = false;
4653 break;
4654
4655 case R_CKCORE_PCREL_IMM26BY2:
4656 case R_CKCORE_PCREL_JSR_IMM26BY2:
4657 case R_CKCORE_PCREL_JSR_IMM11BY2:
4658 case R_CKCORE_PCREL_IMM11BY2:
4659 case R_CKCORE_CALLGRAPH:
4660 /* Emit callgraph information first. */
4661 /* TODO: deal with callgraph. */
4662 if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_CALLGRAPH)
4663 break;
4664 /* Some reloc need further handling. */
4665 /* h == NULL means the symbol is a local symbol,
4666 r_symndx == 0 means the symbol is 'ABS' and
4667 the relocation is already handled in assemble,
4668 here just use for callgraph. */
4669 /* TODO: deal with callgraph. */
4670 if (h == NULL && r_symndx == 0)
4671 {
4672 do_final_relocate = false;
4673 break;
4674 }
4675
4676 /* Ignore weak references to undefined symbols. */
4677 if (h != NULL && h->root.type == bfd_link_hash_undefweak)
4678 {
4679 do_final_relocate = false;
4680 break;
4681 }
4682
4683 /* Using branch stub. */
4684 if (use_branch_stub == true
4685 && ELF32_R_TYPE (rel->r_info) == R_CKCORE_PCREL_IMM26BY2)
4686 {
4687 struct elf32_csky_stub_hash_entry *stub_entry = NULL;
4688 if (sym_must_create_stub (h, info))
4689 stub_entry = elf32_csky_get_stub_entry (input_section,
4690 input_section,
4691 h, rel, htab);
4692 else if (disp > BSR_MAX_FWD_BRANCH_OFFSET
4693 || disp < BSR_MAX_BWD_BRANCH_OFFSET)
4694 stub_entry = elf32_csky_get_stub_entry (input_section,
4695 input_section,
4696 h, rel, htab);
4697 if (stub_entry != NULL)
4698 relocation
4699 = (stub_entry->stub_offset
4700 + stub_entry->stub_sec->output_offset
4701 + stub_entry->stub_sec->output_section->vma);
4702 break;
4703 }
4704
4705 else if (h == NULL
4706 || (h->root.type == bfd_link_hash_defined
4707 && h->dynindx == -1)
4708 || ((h->def_regular && !h->def_dynamic)
4709 && (h->root.type != bfd_link_hash_defweak
4710 || ! bfd_link_pic (info))))
4711 {
4712 if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_PCREL_JSR_IMM26BY2)
4713 {
4714 if (within_range (disp, 26))
4715 {
4716 /* In range for BSR32. */
4717 howto = &csky_elf_howto_table[R_CKCORE_PCREL_IMM26BY2];
4718 read_content_substitute = CSKY_INSN_BSR32;
4719 }
4720 else if (bfd_csky_arch (output_bfd) == CSKY_ARCH_810)
4721 /* if bsr32 cannot reach, generate
4722 "lrw r25, label; jsr r25" instead of
4723 jsri label. */
4724 howto = &csky_elf_howto_table[R_CKCORE_NOJSRI];
4725 } /* if ELF32_R_TYPE (rel->r_info)... */
4726 else if (ELF32_R_TYPE (rel->r_info)
4727 == R_CKCORE_PCREL_JSR_IMM11BY2)
4728 {
4729 if (within_range (disp, 11))
4730 {
4731 /* In range for BSR16. */
4732 howto = &csky_elf_howto_table[R_CKCORE_PCREL_IMM11BY2];
4733 read_content_substitute = CSKY_INSN_BSR16;
4734 }
4735 }
4736 break;
4737 } /* else if h == NULL... */
4738
4739 else if (bfd_csky_arch (output_bfd) == CSKY_ARCH_810
4740 && (ELF32_R_TYPE (rel->r_info)
4741 == R_CKCORE_PCREL_JSR_IMM26BY2))
4742 {
4743 howto = &csky_elf_howto_table[R_CKCORE_NOJSRI];
4744 break;
4745 }
4746 /* Other situation, h->def_dynamic == 1,
4747 undefined_symbol when output file is shared object, etc. */
4748 /* Else fall through. */
4749
4750 case R_CKCORE_ADDR_HI16:
4751 case R_CKCORE_ADDR_LO16:
4752 if (bfd_link_pic (info)
4753 || (!bfd_link_pic (info)
4754 && h != NULL
4755 && h->dynindx != -1
4756 && !h->non_got_ref
4757 && ((h->def_dynamic && !h->def_regular)
4758 || (htab->elf.dynamic_sections_created
4759 && (h->root.type == bfd_link_hash_undefweak
4760 || h->root.type == bfd_link_hash_undefined
4761 || h->root.type == bfd_link_hash_indirect)))))
4762 {
4763 Elf_Internal_Rela outrel;
4764 bool skip, relocate;
4765 bfd_byte *loc;
4766
4767 /* When generating a shared object, these relocations
4768 are copied into the output file to be resolved at
4769 run time. */
4770 skip = false;
4771 relocate = false;
4772
4773 outrel.r_offset =
4774 _bfd_elf_section_offset (output_bfd, info, input_section,
4775 rel->r_offset);
4776 if (outrel.r_offset == (bfd_vma) -1)
4777 skip = true;
4778 else if (outrel.r_offset == (bfd_vma) -2)
4779 {
4780 skip = true;
4781 relocate = true;
4782 }
4783 outrel.r_offset += (input_section->output_section->vma
4784 + input_section->output_offset);
4785 if (skip)
4786 memset (&outrel, 0, sizeof (outrel));
4787 else if (h != NULL
4788 && h->dynindx != -1
4789 && (!bfd_link_pic (info)
4790 || (!SYMBOLIC_BIND (info, h)
4791 && h->root.type == bfd_link_hash_defweak)
4792 || !h->def_regular))
4793 {
4794 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4795 outrel.r_addend = rel->r_addend;
4796 }
4797 else
4798 {
4799 /* This symbol is local, or marked to become local. */
4800 relocate = true;
4801 outrel.r_info = ELF32_R_INFO (0, r_type);
4802 outrel.r_addend = relocation + rel->r_addend;
4803 }
4804 loc = htab->elf.srelgot->contents;
4805 loc += (htab->elf.srelgot->reloc_count++
4806 * sizeof (Elf32_External_Rela));
4807
4808 if (loc != NULL)
4809 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4810
4811 /* If this reloc is against an external symbol, we do not
4812 want to diddle with the addend. Otherwise, we need to
4813 include the symbol value so that it becomes an addend
4814 for the dynamic reloc. */
4815 if (!relocate)
4816 continue;
4817 } /* if bfd_link_pic (info) ... */
4818 break;
4819
4820 case R_CKCORE_ADDR32:
4821 /* r_symndx will be zero only for relocs against symbols
4822 from removed linkonce sections, or sections discarded
4823 by a linker script.
4824 This relocation don't nedd to handle, the value will
4825 be set to SEC_DISCARDED(0xffffffff). */
4826 if (r_symndx == 0
4827 && strcmp (sec->name, ".csky_stack_size") == 0)
4828 {
4829 do_final_relocate = false;
4830 break;
4831 }
4832 if (r_symndx >= symtab_hdr->sh_info
4833 && h->non_got_ref
4834 && bfd_link_executable (info))
4835 break;
4836
4837 if (r_symndx == 0 || (input_section->flags & SEC_ALLOC) == 0)
4838 break;
4839
4840 if (bfd_link_pic (info)
4841 || (h != NULL
4842 && h->dynindx != -1
4843 && ((h->def_dynamic && !h->def_regular)
4844 || (htab->elf.dynamic_sections_created
4845 && (h->root.type == bfd_link_hash_undefweak
4846 || h->root.type == bfd_link_hash_undefined
4847 || h->root.type == bfd_link_hash_indirect)))))
4848 {
4849 Elf_Internal_Rela outrel;
4850 bool skip, relocate;
4851 bfd_byte *loc;
4852
4853 /* When generating a shared object, these relocations
4854 are copied into the output file to be resolved at
4855 run time. */
4856 skip = false;
4857 relocate = false;
4858
4859 outrel.r_offset =
4860 _bfd_elf_section_offset (output_bfd, info, input_section,
4861 rel->r_offset);
4862
4863 if (outrel.r_offset == (bfd_vma) -1)
4864 skip = true;
4865 else if (outrel.r_offset == (bfd_vma) -2)
4866 {
4867 skip = true;
4868 relocate = true;
4869 }
4870
4871 outrel.r_offset += (input_section->output_section->vma
4872 + input_section->output_offset);
4873
4874 if (skip)
4875 memset (&outrel, 0, sizeof (outrel));
4876 else if (h != NULL
4877 && h->dynindx != -1
4878 && (!bfd_link_pic (info)
4879 || (!SYMBOLIC_BIND (info, h)
4880 && h->root.type == bfd_link_hash_defweak)
4881 || !h->def_regular))
4882 {
4883 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4884 outrel.r_addend = rel->r_addend;
4885 }
4886 else
4887 {
4888 /* This symbol is local, or marked to become local. */
4889 outrel.r_info = ELF32_R_INFO (0, R_CKCORE_RELATIVE);
4890 outrel.r_addend = relocation + rel->r_addend;
4891 }
4892
4893 loc = htab->elf.srelgot->contents;
4894 loc += (htab->elf.srelgot->reloc_count++
4895 * sizeof (Elf32_External_Rela));
4896
4897 if (loc != NULL)
4898 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4899
4900 /* If this reloc is against an external symbol, we do
4901 want to diddle with the addend. Otherwise, we need to
4902 include the symbol value so that it becomes an addend
4903 for the dynamic reloc. */
4904 if (! relocate)
4905 continue;
4906 }
4907 break;
4908
4909 case R_CKCORE_TLS_LDO32:
4910 relocation = relocation - dtpoff_base (info);
4911 break;
4912
4913 case R_CKCORE_TLS_LDM32:
4914 BFD_ASSERT (htab->elf.sgot != NULL);
4915 off = htab->tls_ldm_got.offset;
4916 if (off & 1)
4917 off &= ~1;
4918 else
4919 {
4920 /* If we don't know the module number,
4921 create a relocation for it. */
4922 if (!bfd_link_executable (info))
4923 {
4924 Elf_Internal_Rela outrel;
4925 bfd_byte *loc;
4926
4927 BFD_ASSERT (htab->elf.srelgot != NULL);
4928 outrel.r_addend = 0;
4929 outrel.r_offset
4930 = (htab->elf.sgot->output_section->vma
4931 + htab->elf.sgot->output_offset + off);
4932 outrel.r_info = ELF32_R_INFO (0, R_CKCORE_TLS_DTPMOD32);
4933 bfd_put_32 (output_bfd, outrel.r_addend,
4934 htab->elf.sgot->contents + off);
4935
4936 loc = htab->elf.srelgot->contents;
4937 loc += (htab->elf.srelgot->reloc_count++
4938 * sizeof (Elf32_External_Rela));
4939 if (loc)
4940 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4941 }
4942 else
4943 bfd_put_32 (output_bfd, 1,
4944 htab->elf.sgot->contents + off);
4945 htab->tls_ldm_got.offset |= 1;
4946 }
4947 relocation
4948 = (htab->elf.sgot->output_section->vma
4949 + htab->elf.sgot->output_offset + off
4950 - (input_section->output_section->vma
4951 + input_section->output_offset + rel->r_offset));
4952 break;
4953 case R_CKCORE_TLS_LE32:
4954 if (bfd_link_dll (info))
4955 {
4956 _bfd_error_handler
4957 /* xgettext:c-format */
4958 (_("%pB(%pA+%#" PRIx64 "): %s relocation not permitted "
4959 "in shared object"),
4960 input_bfd, input_section, (uint64_t)rel->r_offset,
4961 howto->name);
4962 return false;
4963 }
4964 else
4965 relocation = tpoff (info, relocation);
4966 break;
4967 case R_CKCORE_TLS_GD32:
4968 case R_CKCORE_TLS_IE32:
4969 {
4970 int indx;
4971 char tls_type;
4972
4973 BFD_ASSERT (htab->elf.sgot != NULL);
4974
4975 indx = 0;
4976 if (h != NULL)
4977 {
4978 bool dyn;
4979 dyn = htab->elf.dynamic_sections_created;
4980 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4981 bfd_link_pic (info), h)
4982 && (!bfd_link_pic (info)
4983 || !SYMBOL_REFERENCES_LOCAL (info, h)))
4984 {
4985 unresolved_reloc = false;
4986 indx = h->dynindx;
4987 }
4988 off = h->got.offset;
4989 tls_type = ((struct csky_elf_link_hash_entry *)h)->tls_type;
4990 }
4991 else
4992 {
4993 BFD_ASSERT (local_got_offsets != NULL);
4994 off = local_got_offsets[r_symndx];
4995 tls_type = csky_elf_local_got_tls_type (input_bfd)[r_symndx];
4996 }
4997
4998 BFD_ASSERT (tls_type != GOT_UNKNOWN);
4999
5000 if (off & 1)
5001 off &= ~1;
5002 else
5003 {
5004 bool need_relocs = false;
5005 Elf_Internal_Rela outrel;
5006 bfd_byte *loc = NULL;
5007 int cur_off = off;
5008 /* The GOT entries have not been initialized yet. Do it
5009 now, and emit any relocations. If both an IE GOT and a
5010 GD GOT are necessary, we emit the GD first. */
5011 if ((!bfd_link_executable (info) || indx != 0)
5012 && (h == NULL
5013 || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5014 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
5015 || h->root.type != bfd_link_hash_undefined))
5016 {
5017 need_relocs = true;
5018 BFD_ASSERT (htab->elf.srelgot != NULL);
5019
5020 loc = htab->elf.srelgot->contents;
5021 loc += (htab->elf.srelgot->reloc_count
5022 * sizeof (Elf32_External_Rela));
5023 }
5024 if (tls_type & GOT_TLS_GD)
5025 {
5026 if (need_relocs)
5027 {
5028 outrel.r_addend = 0;
5029 outrel.r_offset
5030 = (htab->elf.sgot->output_section->vma
5031 + htab->elf.sgot->output_offset
5032 + cur_off);
5033 outrel.r_info
5034 = ELF32_R_INFO (indx, R_CKCORE_TLS_DTPMOD32);
5035 bfd_put_32 (output_bfd, outrel.r_addend,
5036 htab->elf.sgot->contents + cur_off);
5037 if (loc)
5038 bfd_elf32_swap_reloca_out (output_bfd,
5039 &outrel, loc);
5040 loc += sizeof (Elf32_External_Rela);
5041 htab->elf.srelgot->reloc_count++;
5042 if (indx == 0)
5043 bfd_put_32 (output_bfd,
5044 relocation - dtpoff_base (info),
5045 (htab->elf.sgot->contents
5046 + cur_off + 4));
5047 else
5048 {
5049 outrel.r_addend = 0;
5050 outrel.r_info
5051 = ELF32_R_INFO (indx, R_CKCORE_TLS_DTPOFF32);
5052 outrel.r_offset += 4;
5053 bfd_put_32 (output_bfd, outrel.r_addend,
5054 (htab->elf.sgot->contents
5055 + cur_off + 4));
5056 outrel.r_info =
5057 ELF32_R_INFO (indx,
5058 R_CKCORE_TLS_DTPOFF32);
5059 if (loc)
5060 bfd_elf32_swap_reloca_out (output_bfd,
5061 &outrel,
5062 loc);
5063 htab->elf.srelgot->reloc_count++;
5064 loc += sizeof (Elf32_External_Rela);
5065 }
5066
5067 }
5068 else
5069 {
5070 /* If are not emitting relocations for a
5071 general dynamic reference, then we must be in a
5072 static link or an executable link with the
5073 symbol binding locally. Mark it as belonging
5074 to module 1, the executable. */
5075 bfd_put_32 (output_bfd, 1,
5076 htab->elf.sgot->contents + cur_off);
5077 bfd_put_32 (output_bfd,
5078 relocation - dtpoff_base (info),
5079 htab->elf.sgot->contents
5080 + cur_off + 4);
5081 }
5082 cur_off += 8;
5083 }
5084 if (tls_type & GOT_TLS_IE)
5085 {
5086 if (need_relocs)
5087 {
5088 if (indx == 0)
5089 outrel.r_addend = relocation - dtpoff_base (info);
5090 else
5091 outrel.r_addend = 0;
5092 outrel.r_offset
5093 = (htab->elf.sgot->output_section->vma
5094 + htab->elf.sgot->output_offset + cur_off);
5095 outrel.r_info
5096 = ELF32_R_INFO (indx, R_CKCORE_TLS_TPOFF32);
5097
5098 bfd_put_32 (output_bfd, outrel.r_addend,
5099 htab->elf.sgot->contents + cur_off);
5100 if (loc)
5101 bfd_elf32_swap_reloca_out (output_bfd,
5102 &outrel, loc);
5103 htab->elf.srelgot->reloc_count++;
5104 loc += sizeof (Elf32_External_Rela);
5105 }
5106 else
5107 bfd_put_32 (output_bfd, tpoff (info, relocation),
5108 htab->elf.sgot->contents + cur_off);
5109 }
5110 if (h != NULL)
5111 h->got.offset |= 1;
5112 else
5113 local_got_offsets[r_symndx] |= 1;
5114 }
5115 if ((tls_type & GOT_TLS_GD) && howto->type != R_CKCORE_TLS_GD32)
5116 off += 8;
5117 relocation
5118 = (htab->elf.sgot->output_section->vma
5119 + htab->elf.sgot->output_offset + off
5120 - (input_section->output_section->vma
5121 + input_section->output_offset
5122 + rel->r_offset));
5123 break;
5124 }
5125 default:
5126 /* No substitution when final linking. */
5127 read_content_substitute = 0;
5128 break;
5129 } /* End switch (howto->type). */
5130
5131 /* Make sure 32-bit data in the text section will not be affected by
5132 our special endianness.
5133 However, this currently affects noting, since the ADDR32 howto type
5134 does no change with the data read. But we may need this mechanism in
5135 the future. */
5136
5137 if (bfd_get_reloc_size (howto) == 4
5138 && (howto->type == R_CKCORE_ADDR32
5139 || howto->type == R_CKCORE_PCREL32
5140 || howto->type == R_CKCORE_GOT32
5141 || howto->type == R_CKCORE_GOTOFF
5142 || howto->type == R_CKCORE_GOTPC
5143 || howto->type == R_CKCORE_PLT32
5144 || howto->type == R_CKCORE_TLS_LE32
5145 || howto->type == R_CKCORE_TLS_IE32
5146 || howto->type == R_CKCORE_TLS_LDM32
5147 || howto->type == R_CKCORE_TLS_GD32
5148 || howto->type == R_CKCORE_TLS_LDO32
5149 || howto->type == R_CKCORE_RELATIVE))
5150 need_reverse_bits = 0;
5151 else
5152 need_reverse_bits = 1;
5153 /* Do the final link. */
5154 if (howto->type != R_CKCORE_PCREL_JSR_IMM11BY2
5155 && howto->type != R_CKCORE_PCREL_JSR_IMM26BY2
5156 && howto->type != R_CKCORE_CALLGRAPH
5157 && do_final_relocate)
5158 r = csky_final_link_relocate (howto, input_bfd, input_section,
5159 contents, rel->r_offset,
5160 relocation, addend);
5161
5162 if (r != bfd_reloc_ok)
5163 {
5164 ret = false;
5165 switch (r)
5166 {
5167 default:
5168 break;
5169 case bfd_reloc_overflow:
5170 if (h != NULL)
5171 name = NULL;
5172 else
5173 {
5174 name = bfd_elf_string_from_elf_section (input_bfd,
5175 symtab_hdr->sh_link,
5176 sym->st_name);
5177 if (name == NULL)
5178 break;
5179 if (*name == '\0')
5180 name = bfd_section_name (sec);
5181 }
5182 (*info->callbacks->reloc_overflow)
5183 (info,
5184 (h ? &h->root : NULL),
5185 name, howto->name, (bfd_vma) 0,
5186 input_bfd, input_section, rel->r_offset);
5187 break;
5188 }
5189 }
5190 } /* End for (;rel < relend; rel++). */
5191 return ret;
5192 }
5193
5194 static bool
5195 csky_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
5196 {
5197 int offset;
5198 size_t size;
5199
5200 switch (note->descsz)
5201 {
5202 default:
5203 return false;
5204 /* Sizeof (struct elf_prstatus) on C-SKY V1 arch. */
5205 case 148:
5206 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
5207 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
5208 offset = 72;
5209 size = 72;
5210 break;
5211 /* Sizeof (struct elf_prstatus) on C-SKY V1 arch. */
5212 case 220:
5213 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
5214 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
5215 offset = 72;
5216 size = 34 * 4;
5217 break;
5218 }
5219 /* Make a ".reg/999" section. */
5220 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
5221 size, note->descpos + offset);
5222 }
5223
5224 static bool
5225 csky_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
5226 {
5227 switch (note->descsz)
5228 {
5229 default:
5230 return false;
5231
5232 /* Sizeof (struct elf_prpsinfo) on linux csky. */
5233 case 124:
5234 elf_tdata (abfd)->core->program
5235 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
5236 elf_tdata (abfd)->core->command
5237 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
5238 }
5239
5240 /* Note that for some reason, a spurious space is tacked
5241 onto the end of the args in some (at least one anyway)
5242 implementations, so strip it off if it exists. */
5243 {
5244 char *command = elf_tdata (abfd)->core->command;
5245 int n = strlen (command);
5246
5247 if (0 < n && command[n - 1] == ' ')
5248 command[n - 1] = '\0';
5249 }
5250
5251 return true;
5252 }
5253
5254 /* Determine whether an object attribute tag takes an integer, a
5255 string or both. */
5256
5257 static int
5258 elf32_csky_obj_attrs_arg_type (int tag)
5259 {
5260 switch (tag)
5261 {
5262 case Tag_compatibility:
5263 return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL;
5264 case Tag_CSKY_ARCH_NAME:
5265 case Tag_CSKY_CPU_NAME:
5266 case Tag_CSKY_FPU_NUMBER_MODULE:
5267 return ATTR_TYPE_FLAG_STR_VAL;
5268 case Tag_CSKY_ISA_FLAGS:
5269 case Tag_CSKY_ISA_EXT_FLAGS:
5270 case Tag_CSKY_DSP_VERSION:
5271 case Tag_CSKY_VDSP_VERSION:
5272 case Tag_CSKY_FPU_VERSION:
5273 case Tag_CSKY_FPU_ABI:
5274 case Tag_CSKY_FPU_ROUNDING:
5275 case Tag_CSKY_FPU_HARDFP:
5276 case Tag_CSKY_FPU_Exception:
5277 case Tag_CSKY_FPU_DENORMAL:
5278 return ATTR_TYPE_FLAG_INT_VAL;
5279 default:
5280 break;
5281 }
5282
5283 return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
5284 }
5285
5286 /* Attribute numbers >=64 (mod 128) can be safely ignored. */
5287
5288 static bool
5289 elf32_csky_obj_attrs_handle_unknown (bfd *abfd ATTRIBUTE_UNUSED,
5290 int tag ATTRIBUTE_UNUSED)
5291 {
5292 return true;
5293 }
5294
5295 /* End of external entry points for sizing and building linker stubs. */
5296
5297 /* CPU-related basic API. */
5298 #define TARGET_BIG_SYM csky_elf32_be_vec
5299 #define TARGET_BIG_NAME "elf32-csky-big"
5300 #define TARGET_LITTLE_SYM csky_elf32_le_vec
5301 #define TARGET_LITTLE_NAME "elf32-csky-little"
5302 #define ELF_ARCH bfd_arch_csky
5303 #define ELF_TARGET_ID CSKY_ELF_DATA
5304 #define ELF_MACHINE_CODE EM_CSKY
5305 #define ELF_MACHINE_ALT1 EM_CSKY_OLD
5306 #define ELF_MAXPAGESIZE 0x1000
5307 #define elf_info_to_howto csky_elf_info_to_howto
5308 #define elf_info_to_howto_rel NULL
5309 #define elf_backend_special_sections csky_elf_special_sections
5310 #define bfd_elf32_bfd_link_hash_table_create csky_elf_link_hash_table_create
5311
5312 /* Target related API. */
5313 #define bfd_elf32_mkobject csky_elf_mkobject
5314 #define bfd_elf32_bfd_merge_private_bfd_data csky_elf_merge_private_bfd_data
5315 #define bfd_elf32_bfd_set_private_flags csky_elf_set_private_flags
5316 #define elf_backend_copy_indirect_symbol csky_elf_copy_indirect_symbol
5317 #define bfd_elf32_bfd_is_target_special_symbol csky_elf_is_target_special_symbol
5318 #define elf_backend_maybe_function_sym csky_elf_maybe_function_sym
5319
5320 /* GC section related API. */
5321 #define elf_backend_can_gc_sections 1
5322 #define elf_backend_gc_mark_hook csky_elf_gc_mark_hook
5323 #define elf_backend_gc_mark_extra_sections elf32_csky_gc_mark_extra_sections
5324
5325 /* Relocation related API. */
5326 #define elf_backend_reloc_type_class csky_elf_reloc_type_class
5327 #define bfd_elf32_bfd_reloc_type_lookup csky_elf_reloc_type_lookup
5328 #define bfd_elf32_bfd_reloc_name_lookup csky_elf_reloc_name_lookup
5329 #define elf_backend_ignore_discarded_relocs csky_elf_ignore_discarded_relocs
5330 #define elf_backend_relocate_section csky_elf_relocate_section
5331 #define elf_backend_check_relocs csky_elf_check_relocs
5332
5333 /* Dynamic relocate related API. */
5334 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
5335 #define elf_backend_adjust_dynamic_symbol csky_elf_adjust_dynamic_symbol
5336 #define elf_backend_late_size_sections csky_elf_late_size_sections
5337 #define elf_backend_finish_dynamic_symbol csky_elf_finish_dynamic_symbol
5338 #define elf_backend_finish_dynamic_sections csky_elf_finish_dynamic_sections
5339 #define elf_backend_rela_normal 1
5340 #define elf_backend_can_refcount 1
5341 #define elf_backend_plt_readonly 1
5342 #define elf_backend_want_got_sym 1
5343 #define elf_backend_want_dynrelro 1
5344 #define elf_backend_got_header_size 12
5345 #define elf_backend_want_got_plt 1
5346
5347 /* C-SKY coredump support. */
5348 #define elf_backend_grok_prstatus csky_elf_grok_prstatus
5349 #define elf_backend_grok_psinfo csky_elf_grok_psinfo
5350
5351 /* Attribute sections. */
5352 #undef elf_backend_obj_attrs_vendor
5353 #define elf_backend_obj_attrs_vendor "csky"
5354 #undef elf_backend_obj_attrs_section
5355 #define elf_backend_obj_attrs_section ".csky.attributes"
5356 #undef elf_backend_obj_attrs_arg_type
5357 #define elf_backend_obj_attrs_arg_type elf32_csky_obj_attrs_arg_type
5358 #undef elf_backend_obj_attrs_section_type
5359 #define elf_backend_obj_attrs_section_type SHT_CSKY_ATTRIBUTES
5360 #define elf_backend_obj_attrs_handle_unknown elf32_csky_obj_attrs_handle_unknown
5361
5362 #include "elf32-target.h"
The GNU Binutils are a collection of binary tools.