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