]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - bfd/elf32-csky.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
x86: Change PLT32 reloc against section to PC32
[thirdparty/binutils-gdb.git] / bfd / elf32-csky.c
CommitLineData
b8891f8d 1/* 32-bit ELF support for C-SKY.
b3adc24a 2 Copyright (C) 1998-2020 Free Software Foundation, Inc.
b8891f8d
AJ		 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"
6e67e6b0 31#include "elf32-csky.h"
b8891f8d
AJ		 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
37enum merge_class
38{
39 CSKY_V1,
40 CSKY_V2
41};
42
43typedef 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
56static 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. */
81static 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 */
fe75f42e 154 bfd_elf_generic_reloc, /* special_function */
b8891f8d
AJ		 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. */
907static 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. */
911static int need_reverse_bits;
912
913/* Used for relaxation. See csky_relocate_contents. */
914static 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
920static reloc_howto_type *
921csky_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
958static reloc_howto_type *
959csky_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
969static reloc_howto_type *
970elf32_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
978static bfd_boolean
979csky_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. */
1013static 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
1020static 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
1032enum stub_insn_type
1033{
1034 INSN16,
1035 INSN32,
1036 DATA_TYPE
1037};
1038
1039bfd_boolean use_branch_stub = TRUE;
1040typedef 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
1048static 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
1056static 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,
1075enum elf32_csky_stub_type
1076{
1077 csky_stub_none,
1078 DEF_STUBS
1079};
1080#undef DEF_STUB
1081
1082typedef 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)},
1089static 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
1097struct 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
1111struct 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. */
1160struct 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;
b8891f8d
AJ		 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. */
1197struct 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. */
1207struct 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
1247static bfd_vma
1248csky_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
1258static void
1259csky_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
1276static asection *
1277elf32_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
1318static char *
1319elf32_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
1354static enum elf32_csky_stub_type
1355csky_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
1402static struct bfd_hash_entry *
1403csky_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;
b8891f8d
AJ		 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
1441static struct bfd_hash_entry *
1442stub_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
1484static void
1485csky_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
1496static struct bfd_link_hash_table *
1497csky_elf_link_hash_table_create (bfd *abfd)
1498{
1499 struct csky_elf_link_hash_table *ret;
986f0783 1500 size_t amt = sizeof (struct csky_elf_link_hash_table);
b8891f8d
AJ		 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
1525static bfd_boolean
1526csky_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
1538static bfd_boolean
1539csky_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
1664static bfd_boolean
1665csky_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;
190eb1dd 1804 if (h->dyn_relocs == NULL)
b8891f8d
AJ		 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
190eb1dd 1819 for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
b8891f8d
AJ		 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
190eb1dd
L		 1832 && h->dyn_relocs != NULL)
1833 h->dyn_relocs->count -= eh->jsri2bsr_refcount;
b8891f8d
AJ		 1834
1835 /* Also discard relocs on undefined weak syms with non-default
1836 visibility. */
190eb1dd 1837 if (h->dyn_relocs != NULL
b8891f8d
AJ		 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))
190eb1dd 1842 h->dyn_relocs = NULL;
b8891f8d
AJ		 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
190eb1dd 1881 h->dyn_relocs = NULL;
b8891f8d
AJ		 1882
1883 keep: ;
1884 }
1885
1886 /* Finally, allocate space. */
190eb1dd 1887 for (p = h->dyn_relocs; p != NULL; p = p->next)
b8891f8d
AJ		 1888 {
1889 asection *srelgot = htab->elf.srelgot;
1890 srelgot->size += p->count * sizeof (Elf32_External_Rela);
1891 }
1892
1893 return TRUE;
1894}
1895
b8891f8d
AJ		 1896/* Set the sizes of the dynamic sections. */
1897
1898static bfd_boolean
1899csky_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 }
fd361982 2051 else if (CONST_STRNEQ (bfd_section_name (s), ".rel") )
b8891f8d
AJ		 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)
2c8e3708
L		 2096 htab->elf.dt_pltgot_required = htab->elf.sgot->size != 0;
2097 return _bfd_elf_add_dynamic_tags (output_bfd, info, relocs);
b8891f8d
AJ		 2098}
2099
2100/* Finish up dynamic symbol handling. We set the contents of various
2101 dynamic sections here. */
2102
2103static bfd_boolean
2104csky_elf_finish_dynamic_symbol (bfd *output_bfd,
2105 struct bfd_link_info *info,
2106 struct elf_link_hash_entry *h,
2107 Elf_Internal_Sym *sym)
2108{
2109 struct csky_elf_link_hash_table *htab;
2110
2111 htab = csky_elf_hash_table (info);
2112 if (htab == NULL)
2113 return FALSE;
2114
2115 /* Sanity check to make sure no unexpected symbol reaches here.
2116 This matches the test in csky_elf_relocate_section handling
2117 of GOT/PLT entries. */
2118 BFD_ASSERT (! (h->dynindx == -1
2119 && !h->forced_local
2120 && h->root.type != bfd_link_hash_undefweak
2121 && bfd_link_pic (info)));
2122
2123 if (h->plt.offset != (bfd_vma) -1)
2124 {
2125 bfd_vma plt_index;
2126 bfd_vma got_offset;
2127 Elf_Internal_Rela rel;
2128 bfd_byte *loc;
2129 asection *plt, *relplt, *gotplt;
2130
2131 plt = htab->elf.splt;
2132 relplt = htab->elf.srelplt;
2133 gotplt = htab->elf.sgotplt;
2134
2135 /* This symbol has an entry in the procedure linkage table. Set
2136 it up. */
2137 BFD_ASSERT (h->dynindx != -1
2138 || ((h->forced_local || bfd_link_executable (info))
2139 && h->def_regular));
2140 BFD_ASSERT (plt != NULL && gotplt != NULL && relplt != NULL);
2141 if (bfd_csky_abi (output_bfd) == CSKY_ABI_V2)
2142 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2143 else
2144 plt_index = h->plt.offset / PLT_ENTRY_SIZE_P - 1;
2145 got_offset = (plt_index + 3) * 4;
2146
2147 /* Fill in the entry in the procedure linkage table. */
2148 if (bfd_csky_abi (output_bfd) == CSKY_ABI_V2)
2149 {
2150 csky_put_insn_32 (output_bfd, csky_elf_plt_entry_v2[0],
2151 plt->contents + h->plt.offset);
2152 csky_put_insn_32 (output_bfd,
2153 (csky_elf_plt_entry_v2[1] | plt_index),
2154 plt->contents + h->plt.offset + 4);
2155 csky_put_insn_32 (output_bfd, csky_elf_plt_entry_v2[2],
2156 plt->contents + h->plt.offset + 8);
2157 }
2158 else
2159 {
2160 int i;
2161 for (i = 0; i < 6; i++)
2162 bfd_put_16 (output_bfd, csky_elf_plt_entry_v1[i],
2163 plt->contents + h->plt.offset + i * 2);
2164 bfd_put_32 (output_bfd, plt_index,
2165 plt->contents + h->plt.offset + i * 2);
2166 }
2167
2168 /* Fill in the entry in the .rel.plt section. */
2169 rel.r_offset = (htab->elf.sgotplt->output_section->vma
2170 + htab->elf.sgotplt->output_offset
2171 + got_offset);
2172 rel.r_info = ELF32_R_INFO (h->dynindx, R_CKCORE_JUMP_SLOT);
2173 rel.r_addend = (plt->output_section->vma
2174 + plt->output_offset
2175 + h->plt.offset);
2176 loc = (htab->elf.srelplt->contents
2177 + plt_index * sizeof (Elf32_External_Rela));
2178
2179 if (loc != NULL)
2180 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
2181 if (! h->def_regular)
2182 {
2183 /* Mark the symbol as undefined, rather than as defined in
2184 the .plt section. Leave the value alone. */
2185 sym->st_shndx = SHN_UNDEF;
2186 /* If the symbol is weak, we do need to clear the value.
2187 Otherwise, the PLT entry would provide a definition for
2188 the symbol even if the symbol wasn't defined anywhere,
2189 and so the symbol would never be NULL. Leave the value if
2190 there were any relocations where pointer equality matters
2191 (this is a clue for the dynamic linker, to make function
2192 pointer comparisons work between an application and shared
2193 library). */
2194 if (!h->ref_regular_nonweak || !h->pointer_equality_needed)
2195 sym->st_value = 0;
2196 }
2197 }
2198
2199 /* Fill in the entry in the .got section. */
2200 if (h->got.offset != (bfd_vma) -1
2201 && ((csky_elf_hash_entry (h)->tls_type & GOT_TLS_GD) == 0)
2202 && ((csky_elf_hash_entry (h)->tls_type & GOT_TLS_IE) == 0))
2203 {
2204 Elf_Internal_Rela rel;
2205 bfd_byte *loc;
2206
2207 /* This symbol has an entry in the global offset table.
2208 Set it up. */
2209 BFD_ASSERT (htab->elf.sgot != NULL && htab->elf.srelgot != NULL);
2210
2211 rel.r_offset = (htab->elf.sgot->output_section->vma
2212 + htab->elf.sgot->output_offset
2213 + (h->got.offset & ~(bfd_vma) 1));
2214
2215 /* If this is a static link, or it is a -Bsymbolic link and the
2216 symbol is defined locally or was forced to be local because
2217 of a version file, we just want to emit a RELATIVE reloc.
2218 The entry in the global offset table will already have been
2219 initialized in the relocate_section function. */
2220 if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h))
2221 {
2222 BFD_ASSERT ((h->got.offset & 1) != 0);
2223 rel.r_info = ELF32_R_INFO (0, R_CKCORE_RELATIVE);
2224 rel.r_addend = (h->root.u.def.value
2225 + h->root.u.def.section->output_offset
2226 + h->root.u.def.section->output_section->vma);
2227 }
2228 else
2229 {
2230 BFD_ASSERT ((h->got.offset & 1) == 0);
2231 bfd_put_32 (output_bfd, (bfd_vma) 0,
2232 htab->elf.sgot->contents + h->got.offset);
2233 rel.r_info = ELF32_R_INFO (h->dynindx, R_CKCORE_GLOB_DAT);
2234 rel.r_addend = 0;
2235 }
2236
2237 loc = htab->elf.srelgot->contents;
2238 loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
2239
2240 if (loc != NULL)
2241 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
2242 }
2243
2244 if (h->needs_copy)
2245 {
2246 asection *s;
2247 Elf_Internal_Rela rela;
2248 bfd_byte *loc;
2249
2250 /* This symbol needs a copy reloc. Set it up. */
2251 BFD_ASSERT (h->dynindx != -1
2252 && (h->root.type == bfd_link_hash_defined
2253 || h->root.type == bfd_link_hash_defweak));
2254
2255 rela.r_offset = (h->root.u.def.value
2256 + h->root.u.def.section->output_section->vma
2257 + h->root.u.def.section->output_offset);
2258 rela.r_info = ELF32_R_INFO (h->dynindx, R_CKCORE_COPY);
2259 rela.r_addend = 0;
2260 if (h->root.u.def.section == htab->elf.sdynrelro)
2261 s = htab->elf.sreldynrelro;
2262 else
2263 s = htab->elf.srelbss;
2264 BFD_ASSERT (s != NULL);
2265 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
2266 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2267 }
2268
2269 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2270 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2271 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2272 sym->st_shndx = SHN_ABS;
2273
2274 return TRUE;
2275}
2276
2277/* Finish up the dynamic sections. */
2278
2279static bfd_boolean
2280csky_elf_finish_dynamic_sections (bfd *output_bfd,
2281 struct bfd_link_info *info)
2282{
2283 struct csky_elf_link_hash_table *htab;
2284 bfd *dynobj;
2285 asection *sdyn;
2286 asection *got_sec;
2287
2288 htab = csky_elf_hash_table (info);
2289 if (htab == NULL)
2290 return FALSE;
2291
2292 dynobj = htab->elf.dynobj;
2293 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2294
2295 if (htab->elf.dynamic_sections_created)
2296 {
2297 Elf32_External_Dyn *dyncon, *dynconend;
2298
2299 BFD_ASSERT (sdyn != NULL && htab->elf.sgot != NULL);
2300
2301 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2302 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2303 for (; dyncon < dynconend; dyncon++)
2304 {
2305 Elf_Internal_Dyn dyn;
2306 bfd_boolean size = FALSE;
2307 const char *name = NULL;
2308
2309 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2310 switch (dyn.d_tag)
2311 {
2312 default:
2313 continue;
2314 case DT_RELA:
2315 name = ".rela.dyn";
2316 size = FALSE;
2317 break;
2318 case DT_RELASZ:
2319 name = ".rela.dyn";
2320 size = TRUE;
2321 break;
2322 case DT_PLTRELSZ:
2323 name = ".rela.plt";
2324 size = TRUE;
2325 break;
2326 case DT_PLTGOT:
2327 dyn.d_un.d_ptr = htab->elf.sgot->output_section->vma;
2328 break;
2329 case DT_JMPREL:
2330 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma
2331 + htab->elf.srelplt->output_offset;
2332 break;
2333 }
2334
2335 if (name != NULL)
2336 {
2337 asection *s = bfd_get_section_by_name (output_bfd, name);
2338
2339 if (s == NULL)
2340 dyn.d_un.d_val = 0;
2341 else if (!size)
2342 dyn.d_un.d_ptr = s->vma;
2343 else
2344 dyn.d_un.d_val = s->size;
2345 }
2346 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2347 }
2348 }
2349
2350 /* Fill in the first three entries in the global offset table. */
2351 if (htab->elf.sgotplt)
2352 got_sec = htab->elf.sgotplt;
2353 else
2354 got_sec = htab->elf.sgot;
2355 if (got_sec != NULL)
2356 {
2357 if (got_sec->size > 0)
2358 {
2359 bfd_put_32 (output_bfd,
2360 (sdyn == NULL ? (bfd_vma) 0
2361 : sdyn->output_section->vma + sdyn->output_offset),
2362 got_sec->contents);
2363 bfd_put_32 (output_bfd, (bfd_vma) 0, got_sec->contents + 4);
2364 bfd_put_32 (output_bfd, (bfd_vma) 0, got_sec->contents + 8);
2365 }
2366 elf_section_data (got_sec->output_section)->this_hdr.sh_entsize = 4;
2367 }
2368 return TRUE;
2369}
2370
2371/* Copy the extra info we tack onto an elf_link_hash_entry. */
2372
2373static void
2374csky_elf_copy_indirect_symbol (struct bfd_link_info *info,
2375 struct elf_link_hash_entry *dir,
2376 struct elf_link_hash_entry *ind)
2377{
2378 struct csky_elf_link_hash_entry *edir, *eind;
2379
2380 edir = (struct csky_elf_link_hash_entry *) dir;
2381 eind = (struct csky_elf_link_hash_entry *) ind;
2382
b8891f8d
AJ		 2383 if (ind->root.type == bfd_link_hash_indirect
2384 && dir->got.refcount <= 0)
2385 {
2386 edir->tls_type = eind->tls_type;
2387 eind->tls_type = GOT_UNKNOWN;
2388 }
2389 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2390}
2391
2392/* Used to decide how to sort relocs in an optimal manner for the
2393 dynamic linker, before writing them out. */
2394
2395static enum elf_reloc_type_class
2396csky_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2397 const asection *rel_sec ATTRIBUTE_UNUSED,
2398 const Elf_Internal_Rela *rela)
2399{
2400 switch ((int) ELF32_R_TYPE (rela->r_info))
2401 {
2402 case R_CKCORE_RELATIVE:
2403 return reloc_class_relative;
2404 case R_CKCORE_JUMP_SLOT:
2405 return reloc_class_plt;
2406 case R_CKCORE_COPY:
2407 return reloc_class_copy;
2408 case R_CKCORE_IRELATIVE:
2409 return reloc_class_ifunc;
2410 default:
2411 return reloc_class_normal;
2412 }
2413}
2414
2415/* Return the section that should be marked against GC for a given
2416 relocation. */
2417
2418static asection *
2419csky_elf_gc_mark_hook (asection *sec,
2420 struct bfd_link_info *info,
2421 Elf_Internal_Rela *rel,
2422 struct elf_link_hash_entry *h,
2423 Elf_Internal_Sym *sym)
2424{
2425 if (h != NULL)
2426 {
2427 switch (ELF32_R_TYPE (rel->r_info))
2428 {
2429 case R_CKCORE_GNU_VTINHERIT:
2430 case R_CKCORE_GNU_VTENTRY:
2431 return NULL;
2432 }
2433 }
2434
2435 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2436}
2437
2438/* Look through the relocs for a section during the first phase.
2439 Since we don't do .gots or .plts, we just need to consider the
2440 virtual table relocs for gc. */
2441
2442static bfd_boolean
2443csky_elf_check_relocs (bfd * abfd,
2444 struct bfd_link_info * info,
2445 asection * sec,
2446 const Elf_Internal_Rela * relocs)
2447{
2448 Elf_Internal_Shdr * symtab_hdr;
2449 struct elf_link_hash_entry ** sym_hashes;
2450 const Elf_Internal_Rela * rel;
2451 const Elf_Internal_Rela * rel_end;
2452 struct csky_elf_link_hash_table *htab;
2453 asection *sreloc;
2454
2455 /* if output type is relocatable, return. */
2456 if (bfd_link_relocatable (info))
2457 return TRUE;
2458
2459 htab = csky_elf_hash_table (info);
2460 if (htab == NULL)
2461 return FALSE;
2462
2463 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
2464 sym_hashes = elf_sym_hashes (abfd);
2465
2466 rel_end = relocs + sec->reloc_count;
2467 sreloc = NULL;
2468 for (rel = relocs; rel < rel_end; rel++)
2469 {
2470 struct elf_link_hash_entry *h;
2471 unsigned long r_symndx;
2472 Elf_Internal_Sym *isym;
2473 int r_type;
2474
2475 r_symndx = ELF32_R_SYM (rel->r_info);
2476 r_type = ELF32_R_TYPE (rel->r_info);
2477 if (r_symndx < symtab_hdr->sh_info)
2478 {
2479 /* A local symbol. */
2480 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2481 abfd, r_symndx);
2482 if (isym == NULL)
2483 return FALSE;
2484 h = NULL;
2485 }
2486 else
2487 {
2488 isym = NULL;
2489 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2490 while (h->root.type == bfd_link_hash_indirect
2491 || h->root.type == bfd_link_hash_warning)
2492 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2493 }
2494
2495 switch (r_type)
2496 {
2497 case R_CKCORE_PCREL_IMM26BY2:
2498 case R_CKCORE_PCREL_IMM11BY2:
2499 case R_CKCORE_PCREL_JSR_IMM11BY2:
2500 case R_CKCORE_PCREL_JSR_IMM26BY2:
2501 /* If the symbol is '*UND*', means this reloc is used for
2502 * callgraph, don't need to leave to shared object. */
2503 if (r_symndx == 0)
2504 break;
2505 /* Else fall through. */
2506 case R_CKCORE_ADDR32:
2507 case R_CKCORE_ADDR_HI16:
2508 case R_CKCORE_ADDR_LO16:
2509 if (h != NULL
2510 && bfd_link_executable (info)
2511 && r_type == R_CKCORE_ADDR32
2512 && h->type == STT_OBJECT
2513 && (sec->flags & SEC_ALLOC) != 0
2514 && (sec->flags & SEC_READONLY))
2515 /* If this reloc is in a read-only section, we might
2516 need a copy reloc. We can't check reliably at this
2517 stage whether the section is read-only, as input
2518 sections have not yet been mapped to output sections.
2519 Tentatively set the flag for now, and correct in
2520 adjust_dynamic_symbol. */
2521 h->non_got_ref = 1;
2522
2523 /* If we are creating a shared library or relocatable executable,
2524 and this is a reloc against a global symbol, then we need to
2525 copy the reloc into the shared library. However, if we are
2526 linking with -Bsymbolic, we do not need to copy a reloc
2527 against a global symbol which is defined in an object we are
2528 including in the link (i.e., DEF_REGULAR is set). At
2529 this point we have not seen all the input files, so it is
2530 possible that DEF_REGULAR is not set now but will be set
2531 later (it is never cleared). We account for that possibility
2532 below by storing information in the relocs_copied field of
2533 the hash table entry. */
2534 if ((bfd_link_pic (info) && (sec->flags & SEC_ALLOC) != 0)
2535 || (!bfd_link_pic (info)
2536 && (sec->flags & SEC_ALLOC) != 0
2537 && h != NULL
2538 && (h->root.type == bfd_link_hash_defweak
2539 || !h->def_regular)))
2540 {
2541 struct elf_dyn_relocs *p;
2542 struct elf_dyn_relocs **head;
2543 /* We must copy these reloc types into the output file.
2544 Create a reloc section in dynobj and make room for
2545 this reloc. */
2546 if (sreloc == NULL)
2547 {
2548 if (htab->elf.dynobj == NULL)
2549 htab->elf.dynobj = abfd;
2550
2551 sreloc = _bfd_elf_make_dynamic_reloc_section
2552 (sec, htab->elf.dynobj, 2, abfd, TRUE);
2553
2554 if (sreloc == NULL)
2555 return FALSE;
2556 }
2557
2558 if (h == NULL && !use_branch_stub
2559 && ((ELF32_R_TYPE (rel->r_info)
2560 == R_CKCORE_PCREL_IMM26BY2)
2561 || (ELF32_R_TYPE (rel->r_info)
2562 == R_CKCORE_PCREL_IMM11BY2)))
2563 break;
2564
2565 /* If this is a global symbol, we count the number of
2566 relocations we need for this symbol. */
2567 if (h != NULL)
2568 {
2569 struct csky_elf_link_hash_entry *eh;
2570 eh = (struct csky_elf_link_hash_entry *)h;
2571 if ((ELF32_R_TYPE (rel->r_info)
2572 == R_CKCORE_PCREL_JSR_IMM26BY2)
2573 || (ELF32_R_TYPE (rel->r_info)
2574 == R_CKCORE_PCREL_JSR_IMM11BY2))
2575 eh->jsri2bsr_refcount += 1;
190eb1dd 2576 head = &h->dyn_relocs;
b8891f8d
AJ		 2577 }
2578 else
2579 {
2580 /* Track dynamic relocs needed for local syms too.
2581 We really need local syms available to do this
2582 easily. Oh well. */
2583 void **vpp;
2584 asection *s;
2585 Elf_Internal_Sym *loc_isym;
2586
2587 loc_isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2588 abfd, r_symndx);
2589 if (loc_isym == NULL)
2590 return FALSE;
2591 s = bfd_section_from_elf_index (abfd, loc_isym->st_shndx);
2592 if (s == NULL)
2593 s = sec;
2594 vpp = &elf_section_data (s)->local_dynrel;
2595 head = (struct elf_dyn_relocs **)vpp;
2596 }
2597
2598 p = *head;
2599 if (p == NULL || p->sec != sec)
2600 {
986f0783 2601 size_t amt = sizeof *p;
b8891f8d
AJ		 2602 p = ((struct elf_dyn_relocs *)
2603 bfd_alloc (htab->elf.dynobj, amt));
2604 if (p == NULL)
2605 return FALSE;
2606 p->next = *head;
2607 *head = p;
2608 p->sec = sec;
2609 p->count = 0;
2610 p->pc_count = 0;
2611 }
2612
2613 if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_PCREL_IMM26BY2
2614 || ELF32_R_TYPE (rel->r_info) == R_CKCORE_PCREL_IMM11BY2)
2615 p->pc_count += 1;
2616 p->count += 1;
2617 }
2618 break;
2619
2620 case R_CKCORE_PLT_IMM18BY4:
2621 case R_CKCORE_PLT32:
2622 /* This symbol requires a procedure linkage table entry. We
2623 actually build the entry in adjust_dynamic_symbol,
2624 because this might be a case of linking PIC code which is
2625 never referenced by a dynamic object, in which case we
2626 don't need to generate a procedure linkage table entry
2627 after all. */
2628
2629 /* If this is a local symbol, we resolve it directly without
2630 creating a procedure linkage table entry. */
2631 if (h == NULL)
2632 continue;
2633 if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_PLT_IMM18BY4)
2634 check_got_overflow = 1;
2635
2636 h->needs_plt = 1;
2637 h->plt.refcount += 1;
2638 h->got.refcount += 1;
2639 ((struct csky_elf_link_hash_entry *)h)->plt_refcount += 1;
2640 break;
2641
2642 case R_CKCORE_GOT12:
2643 case R_CKCORE_PLT12:
2644 case R_CKCORE_GOT32:
2645 case R_CKCORE_GOT_HI16:
2646 case R_CKCORE_GOT_LO16:
2647 case R_CKCORE_PLT_HI16:
2648 case R_CKCORE_PLT_LO16:
2649 case R_CKCORE_GOT_IMM18BY4:
2650 case R_CKCORE_TLS_IE32:
2651 case R_CKCORE_TLS_GD32:
2652 {
2653 int tls_type, old_tls_type;
2654
2655 if (h != NULL
2656 && bfd_link_executable (info)
2657 && r_type == R_CKCORE_GOT_IMM18BY4
2658 && (sec->flags & SEC_ALLOC) != 0
2659 && (sec->flags & SEC_READONLY))
2660 /* If this reloc is in a read-only section, we might
2661 need a copy reloc. We can't check reliably at this
2662 stage whether the section is read-only, as input
2663 sections have not yet been mapped to output sections.
2664 Tentatively set the flag for now, and correct in
2665 adjust_dynamic_symbol. */
2666 h->non_got_ref = 1;
2667
2668 switch (ELF32_R_TYPE (rel->r_info))
2669 {
2670 case R_CKCORE_TLS_IE32:
2671 tls_type = GOT_TLS_IE;
2672 break;
2673 case R_CKCORE_TLS_GD32:
2674 tls_type = GOT_TLS_GD;
2675 break;
2676 default:
2677 tls_type = GOT_NORMAL;
2678 break;
2679 }
2680 if (h != NULL)
2681 {
2682 if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_GOT_IMM18BY4)
2683 check_got_overflow = 1;
2684 h->got.refcount += 1;
2685 old_tls_type = csky_elf_hash_entry (h)->tls_type;
2686 }
2687 else
2688 {
2689 bfd_signed_vma *local_got_refcounts;
2690
2691 /* This is a global offset table entry for a local symbol. */
2692 /* we can write a new function named
2693 elf32_csky_allocate_local_sym_info() to replace
2694 following code. */
2695 local_got_refcounts = elf_local_got_refcounts (abfd);
2696 if (local_got_refcounts == NULL)
2697 {
2698 bfd_size_type size;
2699
2700 size = symtab_hdr->sh_info;
2701 size *= (sizeof (bfd_signed_vma) + sizeof (char));
2702 local_got_refcounts = ((bfd_signed_vma *)
2703 bfd_zalloc (abfd, size));
2704 if (local_got_refcounts == NULL)
2705 return FALSE;
2706 elf_local_got_refcounts (abfd) = local_got_refcounts;
2707 csky_elf_local_got_tls_type (abfd)
2708 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
2709 }
2710 local_got_refcounts[r_symndx] += 1;
2711 old_tls_type = csky_elf_local_got_tls_type (abfd)[r_symndx];
2712 }
2713
2714 /* We will already have issued an error message if there is a
2715 TLS / non-TLS mismatch, based on the symbol type. We don't
2716 support any linker relaxations. So just combine any TLS
2717 types needed. */
2718 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
2719 && tls_type != GOT_NORMAL)
2720 tls_type |= old_tls_type;
2721
2722 if (old_tls_type != tls_type)
2723 {
2724 if (h != NULL)
2725 csky_elf_hash_entry (h)->tls_type = tls_type;
2726 else
2727 csky_elf_local_got_tls_type (abfd)[r_symndx] = tls_type;
2728 }
2729 }
2730 /* Fall through. */
2731
2732 case R_CKCORE_TLS_LDM32:
2733 if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_TLS_LDM32)
2734 htab->tls_ldm_got.refcount++;
2735 /* Fall through. */
2736
2737 case R_CKCORE_GOTOFF:
2738 case R_CKCORE_GOTPC:
2739 case R_CKCORE_GOTOFF_HI16:
2740 case R_CKCORE_GOTOFF_LO16:
2741 case R_CKCORE_GOTPC_HI16:
2742 case R_CKCORE_GOTPC_LO16:
2743 case R_CKCORE_GOTOFF_IMM18:
2744 if (htab->elf.sgot == NULL)
2745 {
2746 if (htab->elf.dynobj == NULL)
2747 htab->elf.dynobj = abfd;
2748 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
2749 return FALSE;
2750 }
2751 break;
2752
2753 /* This relocation describes the C++ object vtable hierarchy.
2754 Reconstruct it for later use during GC. */
2755 case R_CKCORE_GNU_VTINHERIT:
2756 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2757 return FALSE;
2758 break;
2759
2760 /* This relocation describes which C++ vtable entries are actually
2761 used. Record for later use during GC. */
2762 case R_CKCORE_GNU_VTENTRY:
a0ea3a14 2763 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
b8891f8d
AJ		 2764 return FALSE;
2765 break;
2766 }
2767 }
2768
2769 return TRUE;
2770}
2771
2772static const struct bfd_elf_special_section csky_elf_special_sections[]=
2773{
2774 { STRING_COMMA_LEN (".ctors"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2775 { STRING_COMMA_LEN (".dtors"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2776 { NULL, 0, 0, 0, 0 }
2777};
2778
2779/* Function to keep CSKY specific flags in the ELF header. */
2780
2781static bfd_boolean
2782csky_elf_set_private_flags (bfd * abfd, flagword flags)
2783{
2784 BFD_ASSERT (! elf_flags_init (abfd)
2785 || elf_elfheader (abfd)->e_flags == flags);
2786
2787 elf_elfheader (abfd)->e_flags = flags;
2788 elf_flags_init (abfd) = TRUE;
2789 return TRUE;
2790}
2791
2792static csky_arch_for_merge *
2793csky_find_arch_with_eflag (const unsigned long arch_eflag)
2794{
2795 csky_arch_for_merge *csky_arch = NULL;
2796
2797 for (csky_arch = csky_archs; csky_arch->name != NULL; csky_arch++)
2798 if (csky_arch->arch_eflag == arch_eflag)
2799 break;
2800 if (csky_arch == NULL)
2801 {
2802 _bfd_error_handler (_("warning: unrecognized arch eflag '%#lx'"),
2803 arch_eflag);
2804 bfd_set_error (bfd_error_wrong_format);
2805 }
2806 return csky_arch;
2807}
2808
2809/* Merge backend specific data from an object file to the output
2810 object file when linking. */
2811
2812static bfd_boolean
2813csky_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
2814{
2815 bfd *obfd = info->output_bfd;
2816 flagword old_flags;
2817 flagword new_flags;
2818 csky_arch_for_merge *old_arch = NULL;
2819 csky_arch_for_merge *new_arch = NULL;
2820
2821 /* Check if we have the same endianness. */
2822 if (! _bfd_generic_verify_endian_match (ibfd, info))
2823 return FALSE;
2824
2825 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2826 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2827 return TRUE;
2828
2829 new_flags = elf_elfheader (ibfd)->e_flags;
2830 old_flags = elf_elfheader (obfd)->e_flags;
2831
2832 if (! elf_flags_init (obfd))
2833 {
2834 /* First call, no flags set. */
2835 elf_flags_init (obfd) = TRUE;
2836 elf_elfheader (obfd)->e_flags = new_flags;
2837 }
2838 else if (new_flags == old_flags)
2839 /* Do nothing. */
2840 ;
2841 else if (new_flags == 0 || old_flags == 0)
2842 /* When one flag is 0, assign the other one's flag. */
2843 elf_elfheader (obfd)->e_flags = new_flags | old_flags;
2844 else
2845 {
2846 flagword newest_flag = 0;
2847
2848 if ((new_flags & CSKY_ARCH_MASK) != 0
2849 && (old_flags & CSKY_ARCH_MASK) != 0)
2850 {
2851 new_arch = csky_find_arch_with_eflag (new_flags & CSKY_ARCH_MASK);
2852 old_arch = csky_find_arch_with_eflag (old_flags & CSKY_ARCH_MASK);
2853 /* Collect flags like e, f, g. */
2854 newest_flag = (old_flags & (~CSKY_ARCH_MASK))
2855 | (new_flags & (~CSKY_ARCH_MASK));
2856 if (new_arch != NULL && old_arch != NULL)
2857 {
2858 if (new_arch->class != old_arch->class)
2859 {
2860 _bfd_error_handler
2861 /* xgettext:c-format */
2862 (_("%pB: machine flag conflict with target"), ibfd);
2863 bfd_set_error (bfd_error_wrong_format);
2864 return FALSE;
2865 }
2866 else if (new_arch->class_level != old_arch->class_level)
2867 {
2868 csky_arch_for_merge *newest_arch
2869 = (new_arch->class_level > old_arch->class_level
2870 ? new_arch : old_arch);
2871 if (new_arch->do_warning || old_arch->do_warning)
2872 {
2873 _bfd_error_handler
2874 /* xgettext:c-format */
2875 (_("warning: file %pB's arch flag ck%s conflicts with "
2876 "target ck%s, using ck%s"),
2877 ibfd, new_arch->name, old_arch->name,
2878 newest_arch->name);
2879 bfd_set_error (bfd_error_wrong_format);
2880 }
2881
2882 newest_flag |= newest_arch->arch_eflag;
2883 }
2884 else
2885 newest_flag |= ((new_flags & (CSKY_ARCH_MASK | CSKY_ABI_MASK))
2886 | (old_flags
2887 & (CSKY_ARCH_MASK | CSKY_ABI_MASK)));
2888 }
2889 else
2890 newest_flag |= ((new_flags & (CSKY_ARCH_MASK | CSKY_ABI_MASK))
2891 | (old_flags & (CSKY_ARCH_MASK | CSKY_ABI_MASK)));
2892 }
2893 else
2894 newest_flag |= ((new_flags & (CSKY_ARCH_MASK | CSKY_ABI_MASK))
2895 | (old_flags & (CSKY_ARCH_MASK | CSKY_ABI_MASK)));
2896
2897 elf_elfheader (obfd)->e_flags = newest_flag;
2898 }
2899 return TRUE;
2900}
2901
2902/* Ignore the discarded relocs in special sections in link time. */
2903
2904static bfd_boolean
2905csky_elf_ignore_discarded_relocs (asection *sec)
2906{
2907 if (strcmp (sec->name, ".csky_stack_size") == 0)
2908 return TRUE;
2909 return FALSE;
2910}
2911
2912/* .csky_stack_size are not referenced directly. This pass marks all of
2913 them as required. */
2914
2915static bfd_boolean
2916elf32_csky_gc_mark_extra_sections (struct bfd_link_info *info,
2917 elf_gc_mark_hook_fn gc_mark_hook ATTRIBUTE_UNUSED)
2918{
2919 bfd *sub;
2920
2921 _bfd_elf_gc_mark_extra_sections (info, gc_mark_hook);
2922
2923 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
2924 {
2925 asection *o;
2926
2927 for (o = sub->sections; o != NULL; o = o->next)
2928 if (strcmp (o->name, ".csky_stack_size") == 0)
2929 o->gc_mark = 1;
2930 }
2931
2932 return TRUE;
2933}
2934
2935/* The linker repeatedly calls this function for each input section,
2936 in the order that input sections are linked into output sections.
2937 Build lists of input sections to determine groupings between which
2938 we may insert linker stubs. */
2939
2940void
2941elf32_csky_next_input_section (struct bfd_link_info *info,
2942 asection *isec)
2943{
2944 struct csky_elf_link_hash_table *htab = csky_elf_hash_table (info);
2945 if (htab == NULL)
2946 return;
2947 if (isec->output_section->index <= htab->top_index)
2948 {
2949 asection **list = htab->input_list + isec->output_section->index;
2950
2951 if (*list != bfd_abs_section_ptr)
2952 {
2953 /* Steal the link_sec pointer for our list. */
2954#define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
2955 /* This happens to make the list in reverse order,
2956 which we reverse later in group_sections. */
2957 PREV_SEC (isec) = *list;
2958 *list = isec;
2959 }
2960 }
2961}
2962
2963/* See whether we can group stub sections together. Grouping stub
2964 sections may result in fewer stubs. More importantly, we need to
2965 put all .init* and .fini* stubs at the end of the .init or
2966 .fini output sections respectively, because glibc splits the
2967 _init and _fini functions into multiple parts. Putting a stub in
2968 the middle of a function is not a good idea. */
2969
2970static void
2971group_sections (struct csky_elf_link_hash_table *htab,
2972 bfd_size_type stub_group_size,
2973 bfd_boolean stubs_always_after_branch)
2974{
2975 asection **list = htab->input_list;
2976
2977 do
2978 {
2979 asection *tail = *list;
2980 asection *head;
2981
2982 if (tail == bfd_abs_section_ptr)
2983 continue;
2984
2985 /* Reverse the list: we must avoid placing stubs at the
4b24dd1a
AM		 2986 beginning of the section because the beginning of the text
2987 section may be required for an interrupt vector in bare metal
2988 code. */
b8891f8d
AJ		 2989#define NEXT_SEC PREV_SEC
2990 head = NULL;
2991 while (tail != NULL)
2992 {
2993 /* Pop from tail. */
2994 asection *item = tail;
2995 tail = PREV_SEC (item);
2996
2997 /* Push on head. */
2998 NEXT_SEC (item) = head;
2999 head = item;
3000 }
3001
3002 while (head != NULL)
3003 {
3004 asection *curr;
3005 asection *next;
3006 bfd_vma stub_group_start = head->output_offset;
3007 bfd_vma end_of_next;
3008
3009 curr = head;
3010 while (NEXT_SEC (curr) != NULL)
3011 {
3012 next = NEXT_SEC (curr);
3013 end_of_next = next->output_offset + next->size;
3014 if (end_of_next - stub_group_start >= stub_group_size)
3015 /* End of NEXT is too far from start, so stop. */
3016 break;
3017 curr = next;
3018 }
3019
3020 /* OK, the size from the start to the start of CURR is less
3021 * than stub_group_size and thus can be handled by one stub
3022 * section. (Or the head section is itself larger than
3023 * stub_group_size, in which case we may be toast.)
3024 * We should really be keeping track of the total size of
3025 * stubs added here, as stubs contribute to the final output
3026 * section size. */
3027 do
3028 {
3029 next = NEXT_SEC (head);
3030 /* Set up this stub group. */
3031 htab->stub_group[head->id].link_sec = curr;
3032 }
3033 while (head != curr && (head = next) != NULL);
3034
3035 /* But wait, there's more! Input sections up to stub_group_size
3036 * bytes after the stub section can be handled by it too. */
3037 if (!stubs_always_after_branch)
3038 {
3039 stub_group_start = curr->output_offset + curr->size;
3040
3041 while (next != NULL)
3042 {
3043 end_of_next = next->output_offset + next->size;
3044 if (end_of_next - stub_group_start >= stub_group_size)
3045 /* End of NEXT is too far from stubs, so stop. */
3046 break;
3047 /* Add NEXT to the stub group. */
3048 head = next;
3049 next = NEXT_SEC (head);
3050 htab->stub_group[head->id].link_sec = curr;
3051 }
3052 }
3053 head = next;
3054 }
3055 }
3056 while (list++ != htab->input_list + htab->top_index);
3057
3058 free (htab->input_list);
3059#undef PREV_SEC
3060#undef NEXT_SEC
3061}
3062
3063/* If the symbol referenced by bsr is defined in shared object file,
3064 or it is a weak symbol and we aim to create shared object file,
3065 we must create a stub for this bsr. */
3066
3067static bfd_boolean
3068sym_must_create_stub (struct elf_link_hash_entry *h,
3069 struct bfd_link_info *info)
3070{
3071 if (h != NULL
3072 && ((h->def_dynamic && !h->def_regular)
3073 || (bfd_link_pic (info) && h->root.type == bfd_link_hash_defweak)))
3074 return TRUE;
3075 else
3076 return FALSE;
3077}
3078
3079/* Calculate the template, template size and instruction size for a stub.
3080 Return value is the instruction size. */
3081
3082static unsigned int
3083find_stub_size_and_template (enum elf32_csky_stub_type stub_type,
3084 const insn_sequence **stub_template,
3085 int *stub_template_size)
3086{
3087 const insn_sequence *template_sequence = NULL;
3088 int template_size = 0;
3089 int i;
3090 unsigned int size;
3091
3092 template_sequence = stub_definitions[stub_type].template_sequence;
3093 template_size = stub_definitions[stub_type].template_size;
3094
3095 size = 0;
3096 for (i = 0; i < template_size; i++)
3097 {
3098 switch (template_sequence[i].type)
3099 {
3100 case INSN16:
3101 size += 2;
3102 break;
3103
3104 case INSN32:
3105 case DATA_TYPE:
3106 size += 4;
3107 break;
3108
3109 default:
3110 BFD_FAIL ();
3111 return FALSE;
3112 }
3113 }
3114
3115 if (stub_template)
3116 *stub_template = template_sequence;
3117 if (stub_template_size)
3118 *stub_template_size = template_size;
3119
3120 return size;
3121}
3122
3123/* As above, but don't actually build the stub. Just bump offset so
3124 we know stub section sizes. */
3125
3126static bfd_boolean
3127csky_size_one_stub (struct bfd_hash_entry *gen_entry,
3128 void * in_arg ATTRIBUTE_UNUSED)
3129{
3130 struct elf32_csky_stub_hash_entry *stub_entry;
3131 const insn_sequence *template_sequence = NULL;
3132 int template_size = 0;
3133 int size = 0;
3134
3135 /* Massage our args to the form they really have. */
3136 stub_entry = (struct elf32_csky_stub_hash_entry *) gen_entry;
3137
3138 BFD_ASSERT (stub_entry->stub_type > csky_stub_none
3139 && stub_entry->stub_type < ARRAY_SIZE (stub_definitions));
3140 size = find_stub_size_and_template (stub_entry->stub_type,
3141 &template_sequence, &template_size);
3142 stub_entry->stub_size = size;
3143 stub_entry->stub_template = template_sequence;
3144 stub_entry->stub_template_size = template_size;
3145
3146 size = (size + 7) & ~7;
3147 stub_entry->stub_sec->size += size;
3148 return TRUE;
3149}
3150
3151/* Add a new stub entry to the stub hash. Not all fields of the new
3152 stub entry are initialised. */
3153
3154static struct elf32_csky_stub_hash_entry *
3155elf32_csky_add_stub (const char *stub_name,
3156 asection *section,
3157 struct csky_elf_link_hash_table *htab)
3158{
3159 asection *link_sec;
3160 asection *stub_sec;
3161 struct elf32_csky_stub_hash_entry *stub_entry;
3162
3163 stub_sec = elf32_csky_create_or_find_stub_sec (&link_sec, section, htab);
3164 if (stub_sec == NULL)
3165 return NULL;
3166
3167 /* Enter this entry into the linker stub hash table. */
3168 stub_entry = csky_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3169 TRUE, FALSE);
3170 if (stub_entry == NULL)
3171 {
3172 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
3173 section->owner, stub_name);
3174 return NULL;
3175 }
3176
3177 stub_entry->stub_sec = stub_sec;
3178 stub_entry->stub_offset = 0;
3179 stub_entry->id_sec = link_sec;
3180
3181 return stub_entry;
3182}
3183
3184/* Determine and set the size of the stub section for a final link.
3185 The basic idea here is to examine all the relocations looking for
3186 PC-relative calls to a target that is unreachable with a "bsr"
3187 instruction. */
3188
3189bfd_boolean
3190elf32_csky_size_stubs (bfd *output_bfd,
3191 bfd *stub_bfd,
3192 struct bfd_link_info *info,
3193 bfd_signed_vma group_size,
3194 asection *(*add_stub_section) (const char*, asection*),
3195 void (*layout_sections_again) (void))
3196{
3197 bfd_size_type stub_group_size;
3198 bfd_boolean stubs_always_after_branch;
3199 struct csky_elf_link_hash_table *htab = csky_elf_hash_table (info);
3200
3201 if (htab == NULL)
3202 return FALSE;
3203
3204 /* Propagate mach to stub bfd, because it may not have been
3205 finalized when we created stub_bfd. */
3206 bfd_set_arch_mach (stub_bfd, bfd_get_arch (output_bfd),
3207 bfd_get_mach (output_bfd));
3208
3209 /* Stash our params away. */
3210 htab->stub_bfd = stub_bfd;
3211 htab->add_stub_section = add_stub_section;
3212 htab->layout_sections_again = layout_sections_again;
3213 stubs_always_after_branch = group_size < 0;
3214
3215 if (group_size < 0)
3216 stub_group_size = -group_size;
3217 else
3218 stub_group_size = group_size;
3219
3220 if (stub_group_size == 1)
3221 /* The 'bsr' range in abiv2 is +-64MB has to be used as the
3222 default maximum size.
3223 This value is 128K less than that, which allows for 131072
3224 byte stubs. If we exceed that, then we will fail to link.
3225 The user will have to relink with an explicit group size
3226 option. */
3227 stub_group_size = 66977792;
3228
3229 group_sections (htab, stub_group_size, stubs_always_after_branch);
3230
3231 while (1)
3232 {
3233 bfd *input_bfd;
3234 unsigned int bfd_indx;
3235 asection *stub_sec;
3236 bfd_boolean stub_changed = FALSE;
3237
3238 for (input_bfd = info->input_bfds, bfd_indx = 0;
3239 input_bfd != NULL;
3240 input_bfd = input_bfd->link.next, bfd_indx++)
3241 {
3242 Elf_Internal_Shdr *symtab_hdr;
3243 asection *section;
3244 Elf_Internal_Sym *local_syms = NULL;
3245
3246 /* We'll need the symbol table in a second. */
3247 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3248 if (symtab_hdr->sh_info == 0)
3249 continue;
3250
3251 /* Walk over each section attached to the input bfd. */
3252 for (section = input_bfd->sections;
3253 section != NULL;
3254 section = section->next)
3255 {
3256 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
3257
3258 /* If there aren't any relocs, then there's nothing more
3259 * to do. */
3260 if ((section->flags & SEC_RELOC) == 0
3261 || section->reloc_count == 0
3262 || (section->flags & SEC_CODE) == 0)
3263 continue;
3264
3265 /* If this section is a link-once section that will be
3266 discarded, then don't create any stubs. */
3267 if (section->output_section == NULL
3268 || section->output_section->owner != output_bfd)
3269 continue;
3270
3271 /* Get the relocs. */
3272 internal_relocs = _bfd_elf_link_read_relocs (input_bfd,
3273 section,
3274 NULL, NULL,
3275 info->keep_memory);
3276
3277 if (internal_relocs == NULL)
3278 goto error_ret_free_local;
3279
3280 /* Now examine each relocation. */
3281 irela = internal_relocs;
3282 irelaend = irela + section->reloc_count;
3283 for (; irela < irelaend; irela++)
3284 {
3285 unsigned int r_type, r_indx;
3286 enum elf32_csky_stub_type stub_type;
3287 struct elf32_csky_stub_hash_entry *stub_entry;
3288 asection *sym_sec;
3289 bfd_vma sym_value;
3290 bfd_vma destination;
3291 struct csky_elf_link_hash_entry *hash;
3292 const char *sym_name;
3293 char *stub_name;
3294 const asection *id_sec;
3295 unsigned char st_type;
3296
3297 r_type = ELF32_R_TYPE (irela->r_info);
3298 r_indx = ELF32_R_SYM (irela->r_info);
3299 if (r_type >= (unsigned int) R_CKCORE_MAX)
3300 {
3301 bfd_set_error (bfd_error_bad_value);
dc1e8a47 3302 error_ret_free_internal:
b8891f8d
AJ		 3303 if (elf_section_data (section)->relocs == NULL)
3304 free (internal_relocs);
3305 goto error_ret_free_local;
3306 }
3307
3308 /* Only look for stubs on branch instructions. */
3309 if (r_type != (unsigned int) R_CKCORE_PCREL_IMM26BY2)
3310 continue;
3311 /* Now determine the call target, its name, value,
3312 section. */
3313 sym_sec = NULL;
3314 sym_value = 0;
3315 destination = 0;
3316 hash = NULL;
3317 sym_name = NULL;
3318 if (r_indx < symtab_hdr->sh_info)
3319 {
3320 /* It's a local symbol. */
3321 Elf_Internal_Sym *sym;
3322 Elf_Internal_Shdr *hdr;
3323 if (local_syms == NULL)
3324 local_syms =
3325 (Elf_Internal_Sym *) symtab_hdr->contents;
3326 if (local_syms == NULL)
3327 {
3328 local_syms =
3329 bfd_elf_get_elf_syms (input_bfd,
3330 symtab_hdr,
3331 symtab_hdr->sh_info,
3332 0, NULL, NULL, NULL);
3333 if (local_syms == NULL)
3334 goto error_ret_free_internal;
3335 }
3336 sym = local_syms + r_indx;
3337 hdr = elf_elfsections (input_bfd)[sym->st_shndx];
3338 sym_sec = hdr->bfd_section;
3339 if (!sym_sec)
3340 /* This is an undefined symbol. It can never
3341 be resolved. */
3342 continue;
3343 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3344 sym_value = sym->st_value;
3345 destination = (sym_value + irela->r_addend
3346 + sym_sec->output_offset
3347 + sym_sec->output_section->vma);
3348 st_type = ELF_ST_TYPE (sym->st_info);
3349 sym_name =
3350 bfd_elf_string_from_elf_section (input_bfd,
3351 symtab_hdr->sh_link,
3352 sym->st_name);
3353 }
3354 else
3355 {
3356 /* It's an external symbol. */
3357 int e_indx;
3358 e_indx = r_indx - symtab_hdr->sh_info;
3359 hash = ((struct csky_elf_link_hash_entry *)
3360 elf_sym_hashes (input_bfd)[e_indx]);
3361
3362 while (hash->elf.root.type == bfd_link_hash_indirect
3363 || hash->elf.root.type == bfd_link_hash_warning)
3364 hash = ((struct csky_elf_link_hash_entry *)
3365 hash->elf.root.u.i.link);
3366 if (hash->elf.root.type == bfd_link_hash_defined
3367 || hash->elf.root.type == bfd_link_hash_defweak)
3368 {
3369 sym_sec = hash->elf.root.u.def.section;
3370 sym_value = hash->elf.root.u.def.value;
3371
3372 struct csky_elf_link_hash_table *globals =
3373 csky_elf_hash_table (info);
3374 /* FIXME For a destination in a shared library. */
3375 if (globals->elf.splt != NULL && hash != NULL
3376 && hash->elf.plt.offset != (bfd_vma) -1)
3377 continue;
3378 else if (sym_sec->output_section != NULL)
3379 destination = (sym_value + irela->r_addend
3380 + sym_sec->output_offset
3381 + sym_sec->output_section->vma);
3382 }
3383 else if (hash->elf.root.type == bfd_link_hash_undefined
3384 || (hash->elf.root.type
3385 == bfd_link_hash_undefweak))
3386 /* FIXME For a destination in a shared library. */
3387 continue;
3388 else
3389 {
3390 bfd_set_error (bfd_error_bad_value);
3391 goto error_ret_free_internal;
3392 }
3393 st_type = ELF_ST_TYPE (hash->elf.type);
3394 sym_name = hash->elf.root.root.string;
3395 }
3396 do
3397 {
3398 /* Determine what (if any) linker stub is needed. */
3399 stub_type = csky_type_of_stub (info, section, irela,
3400 st_type, hash,
3401 destination, sym_sec,
3402 input_bfd, sym_name);
3403 if (stub_type == csky_stub_none)
3404 break;
3405
3406 /* Support for grouping stub sections. */
3407 id_sec = htab->stub_group[section->id].link_sec;
3408
3409 /* Get the name of this stub. */
3410 stub_name = elf32_csky_stub_name (id_sec, sym_sec, hash,
3411 irela);
3412 if (!stub_name)
3413 goto error_ret_free_internal;
3414 /* We've either created a stub for this reloc already,
3415 or we are about to. */
3416 stub_entry
3417 = csky_stub_hash_lookup (&htab->stub_hash_table,
3418 stub_name,
3419 FALSE, FALSE);
3420 if (stub_entry != NULL)
3421 {
3422 /* The proper stub has already been created. */
3423 free (stub_name);
3424 stub_entry->target_value = sym_value;
3425 break;
3426 }
3427 stub_entry = elf32_csky_add_stub (stub_name, section,
3428 htab);
3429 if (stub_entry == NULL)
3430 {
3431 free (stub_name);
3432 goto error_ret_free_internal;
3433 }
3434 stub_entry->target_value = sym_value;
3435 stub_entry->target_section = sym_sec;
3436 stub_entry->stub_type = stub_type;
3437 stub_entry->h = hash;
3438 stub_entry->st_type = st_type;
3439
3440 if (sym_name == NULL)
3441 sym_name = "unnamed";
3442 stub_entry->output_name =
3443 bfd_alloc (htab->stub_bfd,
3444 (sizeof (STUB_ENTRY_NAME)
3445 + strlen (sym_name)));
3446 if (stub_entry->output_name == NULL)
3447 {
3448 free (stub_name);
3449 goto error_ret_free_internal;
3450 }
3451 sprintf (stub_entry->output_name, STUB_ENTRY_NAME,
3452 sym_name);
3453 stub_changed = TRUE;
3454 }
3455 while (0);
3456 }
3457 /* We're done with the internal relocs, free them. */
3458 if (elf_section_data (section)->relocs == NULL)
3459 free (internal_relocs);
3460 }
3461 }
3462 if (!stub_changed)
3463 break;
3464 /* OK, we've added some stubs. Find out the new size of the
3465 stub sections. */
3466 for (stub_sec = htab->stub_bfd->sections;
3467 stub_sec != NULL;
3468 stub_sec = stub_sec->next)
3469 {
3470 /* Ignore non-stub sections. */
3471 if (!strstr (stub_sec->name, STUB_SUFFIX))
3472 continue;
3473 stub_sec->size = 0;
3474 }
3475 bfd_hash_traverse (&htab->stub_hash_table, csky_size_one_stub, htab);
3476 /* Ask the linker to do its stuff. */
3477 (*htab->layout_sections_again) ();
3478 }
3479
3480 return TRUE;
dc1e8a47 3481 error_ret_free_local:
b8891f8d
AJ		 3482 return FALSE;
3483}
3484
3485static bfd_boolean
3486csky_build_one_stub (struct bfd_hash_entry *gen_entry,
3487 void * in_arg)
3488{
3489#define MAXRELOCS 2
3490 struct elf32_csky_stub_hash_entry *stub_entry;
3491 struct bfd_link_info *info;
3492 asection *stub_sec;
3493 bfd *stub_bfd;
3494 bfd_byte *loc;
3495 bfd_vma sym_value;
3496 int template_size;
3497 int size;
3498 const insn_sequence *template_sequence;
3499 int i;
3500 struct csky_elf_link_hash_table * globals;
3501 int stub_reloc_idx[MAXRELOCS] = {-1, -1};
3502 int stub_reloc_offset[MAXRELOCS] = {0, 0};
3503 int nrelocs = 0;
3504 struct elf_link_hash_entry *h = NULL;
3505
3506 /* Massage our args to the form they really have. */
3507 stub_entry = (struct elf32_csky_stub_hash_entry *)gen_entry;
3508 info = (struct bfd_link_info *) in_arg;
3509
abf874aa
CL		 3510 /* Fail if the target section could not be assigned to an output
3511 section. The user should fix his linker script. */
3512 if (stub_entry->target_section->output_section == NULL
3513 && info->non_contiguous_regions)
53215f21
CL		 3514 info->callbacks->einfo (_("%F%P: Could not assign '%pA' to an output section. "
3515 "Retry without --enable-non-contiguous-regions.\n"),
3516 stub_entry->target_section);
abf874aa 3517
b8891f8d
AJ		 3518 globals = csky_elf_hash_table (info);
3519 if (globals == NULL)
3520 return FALSE;
3521 stub_sec = stub_entry->stub_sec;
3522
3523 /* Make a note of the offset within the stubs for this entry. */
3524 stub_entry->stub_offset = stub_sec->size;
3525 loc = stub_sec->contents + stub_entry->stub_offset;
3526
3527 stub_bfd = stub_sec->owner;
3528
3529 /* This is the address of the stub destination. */
3530 h = &stub_entry->h->elf;
3531 if (sym_must_create_stub (h, info)
3532 && !(bfd_link_pic (info)
3533 && h->root.type == bfd_link_hash_defweak
3534 && h->def_regular
3535 && !h->def_dynamic))
3536 sym_value = 0;
3537 else
3538 sym_value = (stub_entry->target_value
3539 + stub_entry->target_section->output_offset
3540 + stub_entry->target_section->output_section->vma);
3541
3542 template_sequence = stub_entry->stub_template;
3543 template_size = stub_entry->stub_template_size;
3544
3545 size = 0;
3546 for (i = 0; i < template_size; i++)
3547 switch (template_sequence[i].type)
3548 {
3549 case INSN16:
3550 bfd_put_16 (stub_bfd, (bfd_vma) template_sequence[i].data,
3551 loc + size);
3552 size += 2;
3553 break;
3554 case INSN32:
3555 csky_put_insn_32 (stub_bfd, (bfd_vma) template_sequence[i].data,
3556 loc + size);
3557 size += 4;
3558 break;
3559 case DATA_TYPE:
3560 bfd_put_32 (stub_bfd, (bfd_vma) template_sequence[i].data,
3561 loc + size);
3562 stub_reloc_idx[nrelocs] = i;
3563 stub_reloc_offset[nrelocs++] = size;
3564 size += 4;
3565 break;
3566 default:
3567 BFD_FAIL ();
3568 return FALSE;
3569 }
3570 stub_sec->size += size;
3571
3572 /* Stub size has already been computed in csky_size_one_stub. Check
3573 consistency. */
3574 BFD_ASSERT (size == stub_entry->stub_size);
3575
3576 /* Assume there is at least one and at most MAXRELOCS entries to relocate
3577 in each stub. */
3578 BFD_ASSERT (nrelocs != 0 && nrelocs <= MAXRELOCS);
3579
3580 for (i = 0; i < nrelocs; i++)
3581 {
3582 if (sym_must_create_stub (h, info))
3583 {
3584 Elf_Internal_Rela outrel;
3585 asection * sreloc = globals->elf.srelgot;
3586
3587 outrel.r_offset = stub_entry->stub_offset + stub_reloc_offset[i];
3588 outrel.r_info =
3589 ELF32_R_INFO (h->dynindx,
3590 template_sequence[stub_reloc_idx[i]].r_type);
3591 outrel.r_addend = template_sequence[stub_reloc_idx[i]].reloc_addend;
3592
3593 loc = sreloc->contents;
3594 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
3595
3596 if (loc != NULL)
3597 bfd_elf32_swap_reloca_out (info->output_bfd, &outrel, loc);
3598 }
3599 _bfd_final_link_relocate (elf32_csky_howto_from_type
3600 (template_sequence[stub_reloc_idx[i]].r_type),
3601 stub_bfd, stub_sec, stub_sec->contents,
3602 stub_entry->stub_offset + stub_reloc_offset[i],
3603 sym_value + stub_entry->target_addend,
3604 template_sequence[stub_reloc_idx[i]].reloc_addend);
3605 }
3606
3607 return TRUE;
3608#undef MAXRELOCS
3609}
3610
3611/* Build all the stubs associated with the current output file. The
3612 stubs are kept in a hash table attached to the main linker hash
3613 table. We also set up the .plt entries for statically linked PIC
3614 functions here. This function is called via arm_elf_finish in the
3615 linker. */
3616
3617bfd_boolean
3618elf32_csky_build_stubs (struct bfd_link_info *info)
3619{
3620 asection *stub_sec;
3621 struct bfd_hash_table *table;
3622 struct csky_elf_link_hash_table *htab;
3623
3624 htab = csky_elf_hash_table (info);
3625
3626 if (htab == NULL)
3627 return FALSE;
3628
3629 for (stub_sec = htab->stub_bfd->sections;
3630 stub_sec != NULL;
3631 stub_sec = stub_sec->next)
3632 {
3633 bfd_size_type size;
3634
3635 /* Ignore non-stub sections. */
3636 if (!strstr (stub_sec->name, STUB_SUFFIX))
3637 continue;
3638
3639 /* Allocate memory to hold the linker stubs. */
3640 size = stub_sec->size;
3641 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
3642 if (stub_sec->contents == NULL && size != 0)
3643 return FALSE;
3644 stub_sec->size = 0;
3645 }
3646
3647 /* Build the stubs as directed by the stub hash table. */
3648 table = &htab->stub_hash_table;
3649 bfd_hash_traverse (table, csky_build_one_stub, info);
3650
3651 return TRUE;
3652}
3653
3654/* Set up various things so that we can make a list of input sections
3655 for each output section included in the link. Returns -1 on error,
3656 0 when no stubs will be needed, and 1 on success. */
3657
3658int
3659elf32_csky_setup_section_lists (bfd *output_bfd,
3660 struct bfd_link_info *info)
3661{
3662 bfd *input_bfd;
3663 unsigned int bfd_count;
3664 unsigned int top_id, top_index;
3665 asection *section;
3666 asection **input_list, **list;
986f0783 3667 size_t amt;
b8891f8d
AJ		 3668 struct csky_elf_link_hash_table *htab = csky_elf_hash_table (info);
3669
3670 if (!htab)
3671 return 0;
3672 if (! is_elf_hash_table (htab))
3673 return 0;
3674
3675 /* Count the number of input BFDs and find the top input section id. */
3676 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3677 input_bfd != NULL;
3678 input_bfd = input_bfd->link.next)
3679 {
3680 bfd_count += 1;
3681 for (section = input_bfd->sections;
3682 section != NULL;
3683 section = section->next)
3684 if (top_id < section->id)
3685 top_id = section->id;
3686 }
3687 htab->bfd_count = bfd_count;
3688 amt = sizeof (struct map_stub) * (top_id + 1);
3689 htab->stub_group = bfd_zmalloc (amt);
3690 if (htab->stub_group == NULL)
3691 return -1;
3692
3693 /* We can't use output_bfd->section_count here to find the top output
3694 section index as some sections may have been removed, and
3695 _bfd_strip_section_from_output doesn't renumber the indices. */
3696 for (section = output_bfd->sections, top_index = 0;
3697 section != NULL;
3698 section = section->next)
3699 if (top_index < section->index)
3700 top_index = section->index;
3701 htab->top_index = top_index;
3702 amt = sizeof (asection *) * (top_index + 1);
3703 input_list = bfd_malloc (amt);
3704 htab->input_list = input_list;
3705 if (input_list == NULL)
3706 return -1;
3707 /* For sections we aren't interested in, mark their entries with a
3708 value we can check later. */
3709 list = input_list + top_index;
3710 do
3711 *list = bfd_abs_section_ptr;
3712 while (list-- != input_list);
3713 for (section = output_bfd->sections;
3714 section != NULL;
3715 section = section->next)
3716 if ((section->flags & SEC_CODE) != 0)
3717 input_list[section->index] = NULL;
3718
3719 return 1;
3720}
3721
3722static bfd_reloc_status_type
3723csky_relocate_contents (reloc_howto_type *howto,
3724 bfd *input_bfd,
3725 long relocation,
3726 bfd_byte *location)
3727{
3728 int size;
3729 bfd_vma x = 0;
3730 bfd_reloc_status_type flag;
3731 unsigned int rightshift = howto->rightshift;
3732 unsigned int bitpos = howto->bitpos;
3733
3734 /* If the size is negative, negate RELOCATION. This isn't very
3735 general. */
3736 if (howto->size < 0)
3737 relocation = -relocation;
3738
3739 /* FIXME: these macros should be defined at file head or head file head. */
3740#define CSKY_INSN_ADDI_TO_SUBI 0x04000000
279edac5
AM		 3741#define CSKY_INSN_MOV_RTB 0xc41d4820 /* mov32 rx, r29, 0 */
3742#define CSKY_INSN_MOV_RDB 0xc41c4820 /* mov32 rx, r28, 0 */
b8891f8d
AJ		 3743#define CSKY_INSN_GET_ADDI_RZ(x) (((x) & 0x03e00000) >> 21)
3744#define CSKY_INSN_SET_MOV_RZ(x) ((x) & 0x0000001f)
3745#define CSKY_INSN_JSRI_TO_LRW 0xea9a0000
3746#define CSKY_INSN_JSR_R26 0xe8fa0000
3747
3748 /* Get the value we are going to relocate. */
3749 size = bfd_get_reloc_size (howto);
3750 switch (size)
3751 {
3752 default:
3753 case 0:
3754 abort ();
3755 case 1:
3756 x = bfd_get_8 (input_bfd, location);
3757 break;
3758 case 2:
3759 x = bfd_get_16 (input_bfd, location);
3760 break;
3761 case 4:
3762 if (need_reverse_bits)
3763 {
3764 x = csky_get_insn_32 (input_bfd, location);
3765
3766 if (R_CKCORE_DOFFSET_LO16 == howto->type)
3767 {
3768 if ((signed) relocation < 0)
3769 {
3770 x |= CSKY_INSN_ADDI_TO_SUBI;
3771 relocation = -relocation;
3772 }
3773 else if (0 == relocation)
3774 x = (CSKY_INSN_MOV_RDB |
3775 CSKY_INSN_SET_MOV_RZ (CSKY_INSN_GET_ADDI_RZ (x)));
3776 }
3777 else if (R_CKCORE_TOFFSET_LO16 == howto->type)
3778 {
3779 if ((signed) relocation < 0)
3780 {
3781 x |= CSKY_INSN_ADDI_TO_SUBI;
3782 relocation = -relocation;
3783 }
3784 else if (0 == relocation)
3785 x = (CSKY_INSN_MOV_RTB |
3786 CSKY_INSN_SET_MOV_RZ (CSKY_INSN_GET_ADDI_RZ (x)));
3787 }
3788 }
3789 else
3790 x = bfd_get_32 (input_bfd, location);
3791 break;
3792 }
3793 /* Check for overflow. FIXME: We may drop bits during the addition
3794 which we don't check for. We must either check at every single
3795 operation, which would be tedious, or we must do the computations
3796 in a type larger than bfd_vma, which would be inefficient. */
3797 flag = bfd_reloc_ok;
3798 if (howto->complain_on_overflow != complain_overflow_dont)
3799 {
3800 int addrmask;
3801 int fieldmask;
3802 int signmask;
3803 int ss;
3804 int a;
3805 int b;
3806 int sum;
3807 /* Get the values to be added together. For signed and unsigned
3808 relocations, we assume that all values should be truncated to
3809 the size of an address. For bitfields, all the bits matter.
3810 See also bfd_check_overflow. */
3811#define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
3812 fieldmask = N_ONES (howto->bitsize);
3813 signmask = ~fieldmask;
3814 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
3815 a = (relocation & addrmask) >> rightshift;
3816 if (read_content_substitute)
3817 x = read_content_substitute;
3818 b = (x & howto->src_mask & addrmask) >> bitpos;
3819
3820 switch (howto->complain_on_overflow)
3821 {
3822 case complain_overflow_signed:
3823 /* If any sign bits are set, all sign bits must be set.
3824 That is, A must be a valid negative address after
3825 shifting. */
3826 signmask = ~(fieldmask >> 1);
3827 /* Fall through. */
3828
3829 case complain_overflow_bitfield:
3830 /* Much like the signed check, but for a field one bit
3831 wider. We allow a bitfield to represent numbers in the
3832 range -2**n to 2**n-1, where n is the number of bits in the
3833 field. Note that when bfd_vma is 32 bits, a 32-bit reloc
3834 can't overflow, which is exactly what we want. */
3835 ss = a & signmask;
3836 if (ss != 0 && ss != ((addrmask >> rightshift) & signmask))
3837 flag = bfd_reloc_overflow;
3838 /* We only need this next bit of code if the sign bit of B
3839 is below the sign bit of A. This would only happen if
3840 SRC_MASK had fewer bits than BITSIZE. Note that if
3841 SRC_MASK has more bits than BITSIZE, we can get into
3842 trouble; we would need to verify that B is in range, as
3843 we do for A above. */
3844 ss = ((~howto->src_mask) >> 1) & howto->src_mask;
3845 ss >>= bitpos;
3846
3847 /* Set all the bits above the sign bit. */
3848 b = (b ^ ss) - ss;
3849
3850 /* Now we can do the addition. */
3851 sum = a + b;
3852
3853 /* See if the result has the correct sign. Bits above the
3854 sign bit are junk now; ignore them. If the sum is
3855 positive, make sure we did not have all negative inputs;
3856 if the sum is negative, make sure we did not have all
3857 positive inputs. The test below looks only at the sign
3858 bits, and it really just
3859 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
3860
3861 We mask with addrmask here to explicitly allow an address
3862 wrap-around. The Linux kernel relies on it, and it is
3863 the only way to write assembler code which can run when
3864 loaded at a location 0x80000000 away from the location at
3865 which it is linked. */
3866
3867 if (((~(a ^ b)) & (a ^ sum)) & signmask & addrmask)
3868 flag = bfd_reloc_overflow;
3869 break;
3870 case complain_overflow_unsigned:
3871 /* Checking for an unsigned overflow is relatively easy:
3872 trim the addresses and add, and trim the result as well.
3873 Overflow is normally indicated when the result does not
3874 fit in the field. However, we also need to consider the
3875 case when, e.g., fieldmask is 0x7fffffff or smaller, an
3876 input is 0x80000000, and bfd_vma is only 32 bits; then we
3877 will get sum == 0, but there is an overflow, since the
3878 inputs did not fit in the field. Instead of doing a
3879 separate test, we can check for this by or-ing in the
3880 operands when testing for the sum overflowing its final
3881 field. */
3882 sum = (a + b) & addrmask;
3883 if ((a | b | sum) & signmask)
3884 flag = bfd_reloc_overflow;
3885 break;
3886 default:
3887 abort ();
3888 }
3889
3890 }
3891 /* Put RELOCATION in the right bits. */
3892 relocation >>= (bfd_vma) rightshift;
3893
3894 if ((howto->type == R_CKCORE_DOFFSET_LO16
3895 || howto->type == R_CKCORE_TOFFSET_LO16)
3896 && relocation == 0)
3897 /* Do nothing lsli32 rx, rz, 0. */
3898 ;
3899 else
3900 {
3901 /* Fir V1, all this relocation must be x -1. */
3902 if (howto->type == R_CKCORE_PCREL_IMM11BY2
3903 || howto->type == R_CKCORE_PCREL_JSR_IMM11BY2
3904 || howto->type == R_CKCORE_DOFFSET_LO16
3905 || howto->type == R_CKCORE_TOFFSET_LO16)
3906 relocation -= 1;
3907 else if (howto->type == R_CKCORE_PCREL_IMM7BY4)
3908 relocation = (relocation & 0x1f) + ((relocation << 3) & 0x300);
3909 else if (howto->type == R_CKCORE_PCREL_FLRW_IMM8BY4)
3910 relocation
3911 = ((relocation << 4) & 0xf0) + ((relocation << 17) & 0x1e00000);
3912 else if (howto->type == R_CKCORE_NOJSRI)
3913 {
3914 x = (x & howto->dst_mask) | CSKY_INSN_JSRI_TO_LRW;
3915 relocation = 0;
3916 csky_put_insn_32 (input_bfd, CSKY_INSN_JSR_R26, location + 4);
3917 }
3918
3919 relocation <<= (bfd_vma) bitpos;
3920 /* Add RELOCATION to the right bits of X. */
3921 x = ((x & ~howto->dst_mask)
3922 | (((x & howto->src_mask) + relocation) & howto->dst_mask));
3923 }
3924 /* Put the relocated value back in the object file. */
3925 switch (size)
3926 {
3927 default:
3928 abort ();
3929 case 1:
3930 bfd_put_8 (input_bfd, x, location);
3931 break;
3932 case 2:
3933 bfd_put_16 (input_bfd, x, location);
3934 break;
3935 case 4:
3936 if (need_reverse_bits)
3937 csky_put_insn_32 (input_bfd, x, location);
3938 else
3939 bfd_put_32 (input_bfd, x, location);
3940 break;
3941 }
3942 return flag;
3943}
3944
3945/* Look up an entry in the stub hash. Stub entries are cached because
3946 creating the stub name takes a bit of time. */
3947
3948static struct elf32_csky_stub_hash_entry *
3949elf32_csky_get_stub_entry (const asection *input_section,
3950 const asection *sym_sec,
3951 struct elf_link_hash_entry *hash,
3952 const Elf_Internal_Rela *rel,
3953 struct csky_elf_link_hash_table *htab)
3954{
3955 struct elf32_csky_stub_hash_entry *stub_entry;
3956 struct csky_elf_link_hash_entry *h
3957 = (struct csky_elf_link_hash_entry *) hash;
3958 const asection *id_sec;
3959
3960 if ((input_section->flags & SEC_CODE) == 0)
3961 return NULL;
3962
3963 /* If this input section is part of a group of sections sharing one
3964 stub section, then use the id of the first section in the group.
3965 Stub names need to include a section id, as there may well be
3966 more than one stub used to reach say, printf, and we need to
3967 distinguish between them. */
3968 id_sec = htab->stub_group[input_section->id].link_sec;
3969 if (h != NULL && h->stub_cache != NULL
3970 && h->stub_cache->h == h && h->stub_cache->id_sec == id_sec)
3971 stub_entry = h->stub_cache;
3972 else
3973 {
3974 char *stub_name;
3975 stub_name = elf32_csky_stub_name (id_sec, sym_sec, h, rel);
3976 if (stub_name == NULL)
3977 return NULL;
3978 stub_entry = csky_stub_hash_lookup (&htab->stub_hash_table,
3979 stub_name, FALSE, FALSE);
3980 if (h != NULL)
3981 h->stub_cache = stub_entry;
3982 free (stub_name);
3983 }
3984
3985 return stub_entry;
3986}
3987
3988static bfd_reloc_status_type
3989csky_final_link_relocate (reloc_howto_type *howto,
3990 bfd *input_bfd,
3991 asection *input_section,
3992 bfd_byte *contents,
3993 bfd_vma address,
3994 bfd_vma value,
3995 bfd_vma addend)
3996{
3997 bfd_vma relocation;
3998
3999 /* Sanity check the address. */
4000 if (address > bfd_get_section_limit (input_bfd, input_section))
4001 return bfd_reloc_outofrange;
4002
4003 /* This function assumes that we are dealing with a basic relocation
4004 against a symbol. We want to compute the value of the symbol to
4005 relocate to. This is just VALUE, the value of the symbol,
4006 plus ADDEND, any addend associated with the reloc. */
4007 relocation = value + addend;
4008
4009 /* If the relocation is PC relative, we want to set RELOCATION to
4010 the distance between the symbol (currently in RELOCATION) and the
4011 location we are relocating. Some targets (e.g., i386-aout)
4012 arrange for the contents of the section to be the negative of the
4013 offset of the location within the section; for such targets
4014 pcrel_offset is FALSE. Other targets (e.g., m88kbcs or ELF)
4015 simply leave the contents of the section as zero; for such
4016 targets pcrel_offset is TRUE. If pcrel_offset is FALSE we do not
4017 need to subtract out the offset of the location within the
4018 section (which is just ADDRESS). */
4019 if (howto->pc_relative)
4020 {
4021 relocation -= (input_section->output_section->vma
4022 + input_section->output_offset);
4023 if (howto->pcrel_offset)
4024 relocation -= address;
4025 }
4026
4027 return csky_relocate_contents (howto, input_bfd, relocation,
4028 contents + address);
4029
4030}
4031
4032/* Return the base VMA address which should be subtracted from real addresses
4033 when resolving @dtpoff relocation.
4034 This is PT_TLS segment p_vaddr. */
4035
4036static bfd_vma
4037dtpoff_base (struct bfd_link_info *info)
4038{
4039 /* If tls_sec is NULL, we should have signalled an error already. */
4040 if (elf_hash_table (info)->tls_sec == NULL)
4041 return 0;
4042 return elf_hash_table (info)->tls_sec->vma;
4043}
4044
4045/* Return the relocation value for @tpoff relocation
4046 if STT_TLS virtual address is ADDRESS. */
4047
4048static bfd_vma
4049tpoff (struct bfd_link_info *info, bfd_vma address)
4050{
4051 struct elf_link_hash_table *htab = elf_hash_table (info);
4052 bfd_vma base;
4053
4054 /* If tls_sec is NULL, we should have signalled an error already. */
4055 if (htab->tls_sec == NULL)
4056 return 0;
4057 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
4058 return address - htab->tls_sec->vma + base;
4059}
4060
4061/* Relocate a csky section. */
4062
4063static bfd_boolean
4064csky_elf_relocate_section (bfd * output_bfd,
4065 struct bfd_link_info * info,
4066 bfd * input_bfd,
4067 asection * input_section,
4068 bfd_byte * contents,
4069 Elf_Internal_Rela * relocs,
4070 Elf_Internal_Sym * local_syms,
4071 asection ** local_sections)
4072{
4073 Elf_Internal_Shdr *symtab_hdr;
4074 struct elf_link_hash_entry **sym_hashes;
4075 Elf_Internal_Rela *rel;
4076 Elf_Internal_Rela *relend;
4077 const char *name;
4078 bfd_boolean ret = TRUE;
4079 struct csky_elf_link_hash_table * htab;
4080 bfd_vma *local_got_offsets = elf_local_got_offsets (input_bfd);
4081
4082 htab = csky_elf_hash_table (info);
4083 if (htab == NULL)
4084 return FALSE;
4085
4086 symtab_hdr = & elf_symtab_hdr (input_bfd);
4087 sym_hashes = elf_sym_hashes (input_bfd);
4088
4089 rel = relocs;
4090 relend = relocs + input_section->reloc_count;
4091 for (; rel < relend; rel++)
4092 {
4093 enum elf_csky_reloc_type r_type
4094 = (enum elf_csky_reloc_type) ELF32_R_TYPE (rel->r_info);
4095 unsigned long r_symndx;
4096 reloc_howto_type * howto;
4097 Elf_Internal_Sym * sym;
4098 asection * sec;
4099 bfd_vma relocation;
4100 bfd_vma off;
4101 struct elf_link_hash_entry * h;
4102 bfd_vma addend = (bfd_vma)rel->r_addend;
4103 bfd_reloc_status_type r = bfd_reloc_ok;
4104 bfd_boolean unresolved_reloc = FALSE;
4105 int do_final_relocate = TRUE;
4106 bfd_boolean relative_reloc = FALSE;
4107 bfd_signed_vma disp;
4108
4109 /* Ignore these relocation types:
4110 R_CKCORE_GNU_VTINHERIT, R_CKCORE_GNU_VTENTRY. */
4111 if (r_type == R_CKCORE_GNU_VTINHERIT || r_type == R_CKCORE_GNU_VTENTRY)
4112 continue;
4113
4114 if ((unsigned) r_type >= (unsigned) R_CKCORE_MAX)
4115 {
4116 /* The r_type is error, not support it. */
4117 /* xgettext:c-format */
4118 _bfd_error_handler (_("%pB: unsupported relocation type: %#x"),
4119 input_bfd, r_type);
4120 bfd_set_error (bfd_error_bad_value);
4121 ret = FALSE;
4122 continue;
4123 }
4124
4125 howto = &csky_elf_howto_table[(int) r_type];
4126
4127 r_symndx = ELF32_R_SYM(rel->r_info);
4128 h = NULL;
4129 sym = NULL;
4130 sec = NULL;
4131 unresolved_reloc = FALSE;
4132
4133 if (r_symndx < symtab_hdr->sh_info)
4134 {
4135 /* Get symbol table entry. */
4136 sym = local_syms + r_symndx;
4137 sec = local_sections[r_symndx];
4138 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4139 addend = (bfd_vma)rel->r_addend;
4140 }
4141 else
4142 {
4143 bfd_boolean warned, ignored;
4144
4145 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4146 r_symndx, symtab_hdr, sym_hashes,
4147 h, sec, relocation,
4148 unresolved_reloc, warned, ignored);
4149 }
4150
4151 if (sec != NULL && discarded_section (sec))
4152 {
4153 /* For relocs against symbols from removed linkonce sections,
4154 or sections discarded by a linker script, we just want the
4155 section contents zeroed. Avoid any special processing.
4156 And if the symbol is referenced in '.csky_stack_size' section,
4157 set the address to SEC_DISCARDED(0xffffffff). */
4158#if 0
4159 /* The .csky_stack_size section is just for callgraph. */
4160 if (strcmp (input_section->name, ".csky_stack_size") == 0)
4161 {
4162/* FIXME: it should define in head file. */
4163#define SEC_DISCARDED 0xffffffff
4164 bfd_put_32 (input_bfd, SEC_DISCARDED, contents + rel->r_offset);
4165 rel->r_info = 0;
4166 rel->r_addend = 0;
4167 continue;
4168 }
4169 else
4170#endif
4171 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4172 rel, 1, relend, howto, 0,
4173 contents);
4174 }
4175
4176 if (bfd_link_relocatable (info))
4177 continue;
4178
4179 read_content_substitute = 0;
4180
4181 /* Final link. */
4182 disp = (relocation
4183 + (bfd_signed_vma) addend
4184 - input_section->output_section->vma
4185 - input_section->output_offset
4186 - rel->r_offset);
4187/* It is for ck8xx. */
4188#define CSKY_INSN_BSR32 0xe0000000
4189/* It is for ck5xx/ck6xx. */
4190#define CSKY_INSN_BSR16 0xf800
4191#define within_range(x, L) (-(1 << (L - 1)) < (x) && (x) < (1 << (L -1)) - 2)
4192 switch (howto->type)
4193 {
4194 case R_CKCORE_PCREL_IMM18BY2:
4195 /* When h is NULL, means the instruction written as
4196 grs rx, imm32
4197 if the highest bit is set, prevent the high 32bits
4198 turn to 0xffffffff when signed extern in 64bit
4199 host machine. */
4200 if (h == NULL && (addend & 0x80000000))
4201 addend &= 0xffffffff;
4202 break;
fe75f42e
LX		 4203
4204 case R_CKCORE_PCREL32:
4205 break;
4206
b8891f8d
AJ		 4207 case R_CKCORE_GOT12:
4208 case R_CKCORE_PLT12:
4209 case R_CKCORE_GOT_HI16:
4210 case R_CKCORE_GOT_LO16:
4211 case R_CKCORE_PLT_HI16:
4212 case R_CKCORE_PLT_LO16:
4213 case R_CKCORE_GOT32:
4214 case R_CKCORE_GOT_IMM18BY4:
4215 /* Relocation is to the entry for this symbol in the global
4216 offset table. */
4217 BFD_ASSERT (htab->elf.sgot != NULL);
4218 if (h != NULL)
4219 {
4220 /* Global symbol is defined by other modules. */
4221 bfd_boolean dyn;
4222 off = h->got.offset;
4223 dyn = htab->elf.dynamic_sections_created;
4224 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4225 bfd_link_pic (info), h)
4226 || (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info,h))
4227 || (ELF_ST_VISIBILITY(h->other)
4228 && h->root.type == bfd_link_hash_undefweak))
4229 {
4230 /* This is actually a static link, or it is a
4231 -Bsymbolic link and the symbol is defined
4232 locally, or the symbol was forced to be local
4233 because of a version file. We must initialize
4234 this entry in the global offset table. Since the
4235 offset must always be a multiple of 4, we use the
4236 least significant bit to record whether we have
4237 initialized it already.
4238 When doing a dynamic link, we create a .rela.dyn
4239 relocation entry to initialize the value. This
4240 is done in the finish_dynamic_symbol routine. FIXME */
4241 if (off & 1)
4242 off &= ~1;
4243 else
4244 {
4245 bfd_put_32 (output_bfd, relocation,
4246 htab->elf.sgot->contents + off);
4247 h->got.offset |= 1;
4248
4249/* TRUE if relative relocation should be generated. GOT reference to
4250 global symbol in PIC will lead to dynamic symbol. It becomes a
4251 problem when "time" or "times" is defined as a variable in an
4252 executable, clashing with functions of the same name in libc. If a
4253 symbol isn't undefined weak symbol, don't make it dynamic in PIC and
4254 generate relative relocation. */
4255#define GENERATE_RELATIVE_RELOC_P(INFO, H) \
4256 ((H)->dynindx == -1 \
4257 && !(H)->forced_local \
4258 && (H)->root.type != bfd_link_hash_undefweak \
4259 && bfd_link_pic (INFO))
4260
4261 if (GENERATE_RELATIVE_RELOC_P (info, h))
4262 /* If this symbol isn't dynamic
4263 in PIC, generate R_CKCORE_RELATIVE here. */
4264 relative_reloc = TRUE;
4265 }
4266 }
4267 else
4268 unresolved_reloc = FALSE;
4269 } /* End if h != NULL. */
4270 else
4271 {
4272 BFD_ASSERT (local_got_offsets != NULL);
4273 off = local_got_offsets[r_symndx];
4274
4275 /* The offset must always be a multiple of 4. We use
4276 the least significant bit to record whether we have
4277 already generated the necessary reloc. */
4278 if (off & 1)
4279 off &= ~1;
4280 else
4281 {
4282 bfd_put_32 (output_bfd, relocation,
4283 htab->elf.sgot->contents + off);
4284 local_got_offsets[r_symndx] |= 1;
4285 if (bfd_link_pic (info))
4286 relative_reloc = TRUE;
4287 }
4288 }
4289 if (relative_reloc)
4290 {
4291 asection *srelgot;
4292 Elf_Internal_Rela outrel;
4293 bfd_byte *loc;
4294
4295 srelgot = htab->elf.srelgot;
4296 BFD_ASSERT (srelgot != NULL);
4297
4298 outrel.r_offset
4299 = (htab->elf.sgot->output_section->vma
4300 + htab->elf.sgot->output_offset + off);
4301 outrel.r_info = ELF32_R_INFO (0, R_CKCORE_RELATIVE);
4302 outrel.r_addend = relocation;
4303 loc = srelgot->contents;
4304 loc += (srelgot->reloc_count++ * sizeof (Elf32_External_Rela));
4305 if (loc != NULL)
4306 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4307 }
4308 relocation = htab->elf.sgot->output_offset + off;
4309 break;
4310
4311 case R_CKCORE_GOTOFF_IMM18:
4312 case R_CKCORE_GOTOFF:
4313 case R_CKCORE_GOTOFF_HI16:
4314 case R_CKCORE_GOTOFF_LO16:
4315 /* Relocation is relative to the start of the global offset
4316 table. */
4317 /* Note that sgot->output_offset is not involved in this
4318 calculation. We always want the start of .got. If we
4319 defined _GLOBAL_OFFSET_TABLE in a different way, as is
4320 permitted by the ABI, we might have to change this
4321 calculation. */
4322 relocation -= htab->elf.sgot->output_section->vma;
4323 break;
4324
4325 case R_CKCORE_GOTPC:
4326 case R_CKCORE_GOTPC_HI16:
4327 case R_CKCORE_GOTPC_LO16:
4328 /* Use global offset table as symbol value. */
4329 relocation = htab->elf.sgot->output_section->vma;
4330 addend = -addend;
4331 unresolved_reloc = FALSE;
4332 break;
4333
4334 case R_CKCORE_DOFFSET_IMM18:
4335 case R_CKCORE_DOFFSET_IMM18BY2:
4336 case R_CKCORE_DOFFSET_IMM18BY4:
4337 {
4338 asection *sdata = bfd_get_section_by_name (output_bfd, ".data");
4339 relocation -= sdata->output_section->vma;
4340 }
4341 break;
4342
4343 case R_CKCORE_DOFFSET_LO16:
4344 {
4345 asection *sdata = bfd_get_section_by_name (output_bfd, ".data");
4346 relocation -= sdata->output_section->vma;
4347 }
4348 break;
4349
4350 case R_CKCORE_TOFFSET_LO16:
4351 {
4352 asection *stext = bfd_get_section_by_name (output_bfd, ".text");
4353 if (stext)
4354 relocation -= stext->output_section->vma;
4355 }
4356 break;
4357
4358 case R_CKCORE_PLT_IMM18BY4:
4359 case R_CKCORE_PLT32:
4360 /* Relocation is to the entry for this symbol in the
4361 procedure linkage table. */
4362
4363 /* Resolve a PLT32 reloc against a local symbol directly,
4364 without using the procedure linkage table. */
4365 if (h == NULL)
4366 break;
4367
4368 if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
4369 {
4370 /* We didn't make a PLT entry for this symbol. This
4371 happens when statically linking PIC code, or when
4372 using -Bsymbolic. */
4373 if (h->got.offset != (bfd_vma) -1)
4374 {
4375 bfd_boolean dyn;
4376
4377 off = h->got.offset;
4378 dyn = htab->elf.dynamic_sections_created;
4379 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4380 bfd_link_pic (info), h)
4381 || (bfd_link_pic (info)
4382 && SYMBOL_REFERENCES_LOCAL (info, h))
4383 || (ELF_ST_VISIBILITY (h->other)
4384 && h->root.type == bfd_link_hash_undefweak))
4385 {
4386 /* This is actually a static link, or it is a
4387 -Bsymbolic link and the symbol is defined
4388 locally, or the symbol was forced to be local
4389 because of a version file. We must initialize
4390 this entry in the global offset table. Since the
4391 offset must always be a multiple of 4, we use the
4392 least significant bit to record whether we have
4393 initialized it already.
4394
4395 When doing a dynamic link, we create a .rela.dyn
4396 relocation entry to initialize the value. This
4397 is done in the finish_dynamic_symbol routine.
4398 FIXME! */
4399 if (off & 1)
4400 off &= ~1;
4401 else
4402 {
4403 h->got.offset |= 1;
4404 if (GENERATE_RELATIVE_RELOC_P (info, h))
4b24dd1a 4405 relative_reloc = TRUE;
b8891f8d
AJ		 4406 }
4407 }
4408 bfd_put_32 (output_bfd, relocation,
4409 htab->elf.sgot->contents + off);
4410
4411 if (relative_reloc)
4412 {
4413 asection *srelgot;
4414 Elf_Internal_Rela outrel;
4415 bfd_byte *loc;
4416
4417 srelgot = htab->elf.srelgot;
4418 BFD_ASSERT (srelgot != NULL);
4419
4420 outrel.r_offset
4421 = (htab->elf.sgot->output_section->vma
4422 + htab->elf.sgot->output_offset + off);
4423 outrel.r_info = ELF32_R_INFO (0, R_CKCORE_RELATIVE);
4424 outrel.r_addend = relocation;
4425 loc = srelgot->contents;
4426 loc += (srelgot->reloc_count++
4427 * sizeof (Elf32_External_Rela));
4428 if (loc != NULL)
4429 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4430 }
4431 relocation = off + htab->elf.sgot->output_offset;
4432 }
4433 break;
4434 }
4435 /* The relocation is the got offset. */
4436 if (bfd_csky_abi (output_bfd) == CSKY_ABI_V2)
4437 relocation = (h->plt.offset / PLT_ENTRY_SIZE + 2) * 4;
4438 else
4439 relocation = (h->plt.offset / PLT_ENTRY_SIZE_P + 2) * 4;
4440 unresolved_reloc = FALSE;
4441 break;
4442
4443 case R_CKCORE_PCREL_IMM26BY2:
4444 case R_CKCORE_PCREL_JSR_IMM26BY2:
4445 case R_CKCORE_PCREL_JSR_IMM11BY2:
4446 case R_CKCORE_PCREL_IMM11BY2:
4447 case R_CKCORE_CALLGRAPH:
4448 /* Emit callgraph information first. */
4449 /* TODO: deal with callgraph. */
4450 if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_CALLGRAPH)
4451 break;
4452 /* Some reloc need further handling. */
4453 /* h == NULL means the symbol is a local symbol,
4454 r_symndx == 0 means the symbol is 'ABS' and
4455 the relocation is already handled in assemble,
4456 here just use for callgraph. */
4457 /* TODO: deal with callgraph. */
4458 if (h == NULL && r_symndx == 0)
4459 {
4460 do_final_relocate = FALSE;
4461 break;
4462 }
4463
4464 /* Ignore weak references to undefined symbols. */
4465 if (h != NULL && h->root.type == bfd_link_hash_undefweak)
4466 {
4467 do_final_relocate = FALSE;
4468 break;
4469 }
4470
4471 /* Using branch stub. */
4472 if (use_branch_stub == TRUE
4473 && ELF32_R_TYPE (rel->r_info) == R_CKCORE_PCREL_IMM26BY2)
4474 {
4475 struct elf32_csky_stub_hash_entry *stub_entry = NULL;
4476 if (sym_must_create_stub (h, info))
4477 stub_entry = elf32_csky_get_stub_entry (input_section,
4478 input_section,
4479 h, rel, htab);
4480 else if (disp > BSR_MAX_FWD_BRANCH_OFFSET
4481 || disp < BSR_MAX_BWD_BRANCH_OFFSET)
4482 stub_entry = elf32_csky_get_stub_entry (input_section,
4483 input_section,
4484 h, rel, htab);
4485 if (stub_entry != NULL)
4486 relocation
4487 = (stub_entry->stub_offset
4488 + stub_entry->stub_sec->output_offset
4489 + stub_entry->stub_sec->output_section->vma);
4490 break;
4491 }
4492
4493 else if (h == NULL
4494 || (h->root.type == bfd_link_hash_defined
4495 && h->dynindx == -1)
4496 || ((h->def_regular && !h->def_dynamic)
4497 && (h->root.type != bfd_link_hash_defweak
4498 || ! bfd_link_pic (info))))
4499 {
4500 if (ELF32_R_TYPE (rel->r_info) == R_CKCORE_PCREL_JSR_IMM26BY2)
4501 {
4502 if (within_range (disp, 26))
4503 {
4504 /* In range for BSR32. */
4505 howto = &csky_elf_howto_table[R_CKCORE_PCREL_IMM26BY2];
4506 read_content_substitute = CSKY_INSN_BSR32;
4507 }
4508 else if (bfd_csky_arch (output_bfd) == CSKY_ARCH_810)
4509 /* if bsr32 cannot reach, generate
4510 "lrw r25, label; jsr r25" instead of
4511 jsri label. */
4512 howto = &csky_elf_howto_table[R_CKCORE_NOJSRI];
4513 } /* if ELF32_R_TYPE (rel->r_info)... */
4514 else if (ELF32_R_TYPE (rel->r_info)
4515 == R_CKCORE_PCREL_JSR_IMM11BY2)
4516 {
4517 if (within_range (disp, 11))
4518 {
4519 /* In range for BSR16. */
4520 howto = &csky_elf_howto_table[R_CKCORE_PCREL_IMM11BY2];
4521 read_content_substitute = CSKY_INSN_BSR16;
4522 }
4523 }
4524 break;
4525 } /* else if h == NULL... */
4526
4527 else if (bfd_csky_arch (output_bfd) == CSKY_ARCH_810
4528 && (ELF32_R_TYPE (rel->r_info)
4529 == R_CKCORE_PCREL_JSR_IMM26BY2))
4530 {
4531 howto = &csky_elf_howto_table[R_CKCORE_NOJSRI];
4532 break;
4533 }
4534 /* Other situation, h->def_dynamic == 1,
4535 undefined_symbol when output file is shared object, etc. */
4536 /* Else fall through. */
4537
4538 case R_CKCORE_ADDR_HI16:
4539 case R_CKCORE_ADDR_LO16:
4540 if (bfd_link_pic (info)
4541 || (!bfd_link_pic (info)
4542 && h != NULL
4543 && h->dynindx != -1
4544 && !h->non_got_ref
4545 && ((h->def_dynamic && !h->def_regular)
4546 || (htab->elf.dynamic_sections_created
4547 && (h->root.type == bfd_link_hash_undefweak
4548 || h->root.type == bfd_link_hash_undefined
4549 || h->root.type == bfd_link_hash_indirect)))))
4550 {
4551 Elf_Internal_Rela outrel;
4552 bfd_boolean skip, relocate;
4553 bfd_byte *loc;
4554
4555 /* When generating a shared object, these relocations
4556 are copied into the output file to be resolved at
4557 run time. */
4558 skip = FALSE;
4559 relocate = FALSE;
4560
4561 outrel.r_offset =
4562 _bfd_elf_section_offset (output_bfd, info, input_section,
4563 rel->r_offset);
4564 if (outrel.r_offset == (bfd_vma) -1)
4565 skip = TRUE;
4566 else if (outrel.r_offset == (bfd_vma) -2)
4567 {
4568 skip = TRUE;
4569 relocate = TRUE;
4570 }
4571 outrel.r_offset += (input_section->output_section->vma
4572 + input_section->output_offset);
4573 if (skip)
4574 memset (&outrel, 0, sizeof (outrel));
4575 else if (h != NULL
4576 && h->dynindx != -1
4577 && (!bfd_link_pic (info)
4578 || (!SYMBOLIC_BIND (info, h)
4579 && h->root.type == bfd_link_hash_defweak)
4580 || !h->def_regular))
4581 {
4582 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4583 outrel.r_addend = rel->r_addend;
4584 }
4585 else
4586 {
4587 /* This symbol is local, or marked to become local. */
4588 relocate = TRUE;
4589 outrel.r_info = ELF32_R_INFO (0, r_type);
4590 outrel.r_addend = relocation + rel->r_addend;
4591 }
4592 loc = htab->elf.srelgot->contents;
4593 loc += (htab->elf.srelgot->reloc_count++
4594 * sizeof (Elf32_External_Rela));
4595
4596 if (loc != NULL)
4597 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4598
4599 /* If this reloc is against an external symbol, we do not
4600 want to diddle with the addend. Otherwise, we need to
4601 include the symbol value so that it becomes an addend
4602 for the dynamic reloc. */
4603 if (!relocate)
4604 continue;
4605 } /* if bfd_link_pic (info) ... */
4606 break;
4607
4608 case R_CKCORE_ADDR32:
4609 /* r_symndx will be zero only for relocs against symbols
4610 from removed linkonce sections, or sections discarded
4611 by a linker script.
4612 This relocation don't nedd to handle, the value will
4613 be set to SEC_DISCARDED(0xffffffff). */
4614 if (r_symndx == 0
4615 && strcmp (sec->name, ".csky_stack_size") == 0)
4616 {
4617 do_final_relocate = FALSE;
4618 break;
4619 }
4620 if (r_symndx >= symtab_hdr->sh_info
4621 && h->non_got_ref
4622 && bfd_link_executable (info))
4623 break;
4624
4625 if (r_symndx == 0 || (input_section->flags & SEC_ALLOC) == 0)
4626 break;
4627
4628 if (bfd_link_pic (info)
4629 || (h != NULL
4630 && h->dynindx != -1
4631 && ((h->def_dynamic && !h->def_regular)
4632 || (htab->elf.dynamic_sections_created
4633 && (h->root.type == bfd_link_hash_undefweak
4634 || h->root.type == bfd_link_hash_undefined
4635 || h->root.type == bfd_link_hash_indirect)))))
4636 {
4637 Elf_Internal_Rela outrel;
4638 bfd_boolean skip, relocate;
4639 bfd_byte *loc;
4640
4641 /* When generating a shared object, these relocations
4642 are copied into the output file to be resolved at
4643 run time. */
4644 skip = FALSE;
4645 relocate = FALSE;
4646
4647 outrel.r_offset =
4648 _bfd_elf_section_offset (output_bfd, info, input_section,
4649 rel->r_offset);
4650
4651 if (outrel.r_offset == (bfd_vma) -1)
4652 skip = TRUE;
4653 else if (outrel.r_offset == (bfd_vma) -2)
4654 {
4655 skip = TRUE;
4656 relocate = TRUE;
4657 }
4658
4659 outrel.r_offset += (input_section->output_section->vma
4660 + input_section->output_offset);
4661
4662 if (skip)
4663 memset (&outrel, 0, sizeof (outrel));
4664 else if (h != NULL
4665 && h->dynindx != -1
4666 && (!bfd_link_pic (info)
4667 || (!SYMBOLIC_BIND (info, h)
4668 && h->root.type == bfd_link_hash_defweak)
4669 || !h->def_regular))
4670 {
4671 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4672 outrel.r_addend = rel->r_addend;
4673 }
4674 else
4675 {
4676 /* This symbol is local, or marked to become local. */
4677 outrel.r_info = ELF32_R_INFO (0, R_CKCORE_RELATIVE);
4678 outrel.r_addend = relocation + rel->r_addend;
4679 }
4680
4681 loc = htab->elf.srelgot->contents;
4682 loc += (htab->elf.srelgot->reloc_count++
4683 * sizeof (Elf32_External_Rela));
4684
4685 if (loc != NULL)
4686 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4687
4688 /* If this reloc is against an external symbol, we do
4689 want to diddle with the addend. Otherwise, we need to
4690 include the symbol value so that it becomes an addend
4691 for the dynamic reloc. */
4692 if (! relocate)
4693 continue;
4694 }
4695 break;
4696
4697 case R_CKCORE_TLS_LDO32:
4698 relocation = relocation - dtpoff_base (info);
4699 break;
4700
4701 case R_CKCORE_TLS_LDM32:
4702 BFD_ASSERT (htab->elf.sgot != NULL);
4703 off = htab->tls_ldm_got.offset;
4704 if (off & 1)
4705 off &= ~1;
4706 else
4707 {
4708 /* If we don't know the module number,
4709 create a relocation for it. */
4710 if (!bfd_link_executable (info))
4711 {
4712 Elf_Internal_Rela outrel;
4713 bfd_byte *loc;
4714
4715 BFD_ASSERT (htab->elf.srelgot != NULL);
4716 outrel.r_addend = 0;
4717 outrel.r_offset
4718 = (htab->elf.sgot->output_section->vma
4719 + htab->elf.sgot->output_offset + off);
4720 outrel.r_info = ELF32_R_INFO (0, R_CKCORE_TLS_DTPMOD32);
4721 bfd_put_32 (output_bfd, outrel.r_addend,
4722 htab->elf.sgot->contents + off);
4723
4724 loc = htab->elf.srelgot->contents;
4725 loc += (htab->elf.srelgot->reloc_count++
4726 * sizeof (Elf32_External_Rela));
4727 if (loc)
4728 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4729 }
4730 else
4731 bfd_put_32 (output_bfd, 1,
4732 htab->elf.sgot->contents + off);
4733 htab->tls_ldm_got.offset |= 1;
4734 }
4735 relocation
4736 = (htab->elf.sgot->output_section->vma
4737 + htab->elf.sgot->output_offset + off
4738 - (input_section->output_section->vma
4739 + input_section->output_offset + rel->r_offset));
4740 break;
4741 case R_CKCORE_TLS_LE32:
4742 if (bfd_link_dll (info))
4743 {
4744 _bfd_error_handler
4745 /* xgettext:c-format */
4746 (_("%pB(%pA+%#" PRIx64 "): %s relocation not permitted "
4747 "in shared object"),
4748 input_bfd, input_section, (uint64_t)rel->r_offset,
4749 howto->name);
4750 return FALSE;
4751 }
4752 else
4753 relocation = tpoff (info, relocation);
4754 break;
4755 case R_CKCORE_TLS_GD32:
4756 case R_CKCORE_TLS_IE32:
4757 {
4758 int indx;
4759 char tls_type;
4760
4761 BFD_ASSERT (htab->elf.sgot != NULL);
4762
4763 indx = 0;
4764 if (h != NULL)
4765 {
4766 bfd_boolean dyn;
4767 dyn = htab->elf.dynamic_sections_created;
4768 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4769 bfd_link_pic (info), h)
4770 && (!bfd_link_pic (info)
4771 || !SYMBOL_REFERENCES_LOCAL (info, h)))
4772 {
4773 unresolved_reloc = FALSE;
4774 indx = h->dynindx;
4775 }
4776 off = h->got.offset;
4777 tls_type = ((struct csky_elf_link_hash_entry *)h)->tls_type;
4778 }
4779 else
4780 {
4781 BFD_ASSERT (local_got_offsets != NULL);
4782 off = local_got_offsets[r_symndx];
4783 tls_type = csky_elf_local_got_tls_type (input_bfd)[r_symndx];
4784 }
4785
4786 BFD_ASSERT (tls_type != GOT_UNKNOWN);
4787
4788 if (off & 1)
4789 off &= ~1;
4790 else
4791 {
4792 bfd_boolean need_relocs = FALSE;
4793 Elf_Internal_Rela outrel;
4794 bfd_byte *loc = NULL;
4795 int cur_off = off;
4796 /* The GOT entries have not been initialized yet. Do it
4797 now, and emit any relocations. If both an IE GOT and a
4798 GD GOT are necessary, we emit the GD first. */
4799 if ((!bfd_link_executable (info) || indx != 0)
4800 && (h == NULL
4801 || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4802 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
4803 || h->root.type != bfd_link_hash_undefined))
4804 {
4805 need_relocs = TRUE;
4806 BFD_ASSERT (htab->elf.srelgot != NULL);
4807
4808 loc = htab->elf.srelgot->contents;
4809 loc += (htab->elf.srelgot->reloc_count
4810 * sizeof (Elf32_External_Rela));
4811 }
4812 if (tls_type & GOT_TLS_GD)
4813 {
4814 if (need_relocs)
4815 {
4816 outrel.r_addend = 0;
4817 outrel.r_offset
4818 = (htab->elf.sgot->output_section->vma
4819 + htab->elf.sgot->output_offset
4820 + cur_off);
4821 outrel.r_info
4822 = ELF32_R_INFO (indx, R_CKCORE_TLS_DTPMOD32);
4823 bfd_put_32 (output_bfd, outrel.r_addend,
4824 htab->elf.sgot->contents + cur_off);
4825 if (loc)
4826 bfd_elf32_swap_reloca_out (output_bfd,
4827 &outrel, loc);
4828 loc += sizeof (Elf32_External_Rela);
4829 htab->elf.srelgot->reloc_count++;
4830 if (indx == 0)
4831 bfd_put_32 (output_bfd,
4832 relocation - dtpoff_base (info),
4833 (htab->elf.sgot->contents
4834 + cur_off + 4));
4835 else
4836 {
4837 outrel.r_addend = 0;
4838 outrel.r_info
4839 = ELF32_R_INFO (indx, R_CKCORE_TLS_DTPOFF32);
4840 outrel.r_offset += 4;
4841 bfd_put_32 (output_bfd, outrel.r_addend,
4842 (htab->elf.sgot->contents
4843 + cur_off + 4));
4844 outrel.r_info =
4845 ELF32_R_INFO (indx,
4846 R_CKCORE_TLS_DTPOFF32);
4847 if (loc)
4848 bfd_elf32_swap_reloca_out (output_bfd,
4849 &outrel,
4850 loc);
4851 htab->elf.srelgot->reloc_count++;
4852 loc += sizeof (Elf32_External_Rela);
4853 }
4854
4855 }
4856 else
4857 {
4858 /* If are not emitting relocations for a
4859 general dynamic reference, then we must be in a
4860 static link or an executable link with the
4861 symbol binding locally. Mark it as belonging
4862 to module 1, the executable. */
4863 bfd_put_32 (output_bfd, 1,
4864 htab->elf.sgot->contents + cur_off);
4865 bfd_put_32 (output_bfd,
4866 relocation - dtpoff_base (info),
4867 htab->elf.sgot->contents
4868 + cur_off + 4);
4869 }
4870 cur_off += 8;
4871 }
4872 if (tls_type & GOT_TLS_IE)
4873 {
4874 if (need_relocs)
4875 {
4876 if (indx == 0)
4877 outrel.r_addend = relocation - dtpoff_base (info);
4878 else
4879 outrel.r_addend = 0;
4880 outrel.r_offset
4881 = (htab->elf.sgot->output_section->vma
4882 + htab->elf.sgot->output_offset + cur_off);
4883 outrel.r_info
4884 = ELF32_R_INFO (indx, R_CKCORE_TLS_TPOFF32);
4885
4886 bfd_put_32 (output_bfd, outrel.r_addend,
4887 htab->elf.sgot->contents + cur_off);
4888 if (loc)
4889 bfd_elf32_swap_reloca_out (output_bfd,
4890 &outrel, loc);
4891 htab->elf.srelgot->reloc_count++;
4892 loc += sizeof (Elf32_External_Rela);
4893 }
4894 else
4895 bfd_put_32 (output_bfd, tpoff (info, relocation),
4896 htab->elf.sgot->contents + cur_off);
4897 }
4898 if (h != NULL)
4899 h->got.offset |= 1;
4900 else
4901 local_got_offsets[r_symndx] |= 1;
4902 }
4903 if ((tls_type & GOT_TLS_GD) && howto->type != R_CKCORE_TLS_GD32)
4904 off += 8;
4905 relocation
4906 = (htab->elf.sgot->output_section->vma
4907 + htab->elf.sgot->output_offset + off
4908 - (input_section->output_section->vma
4909 + input_section->output_offset
4910 + rel->r_offset));
4911 break;
4912 }
4913 default:
4914 /* No substitution when final linking. */
4915 read_content_substitute = 0;
4916 break;
4917 } /* End switch (howto->type). */
4918
4919 /* Make sure 32-bit data in the text section will not be affected by
4920 our special endianness.
4921 However, this currently affects noting, since the ADDR32 howto type
4922 does no change with the data read. But we may need this mechanism in
4923 the future. */
4924
4925 if (howto->size == 2
4926 && (howto->type == R_CKCORE_ADDR32
fe75f42e 4927 || howto->type == R_CKCORE_PCREL32
b8891f8d
AJ		 4928 || howto->type == R_CKCORE_GOT32
4929 || howto->type == R_CKCORE_GOTOFF
4930 || howto->type == R_CKCORE_GOTPC
4931 || howto->type == R_CKCORE_PLT32
4932 || howto->type == R_CKCORE_TLS_LE32
4933 || howto->type == R_CKCORE_TLS_IE32
4934 || howto->type == R_CKCORE_TLS_LDM32
4935 || howto->type == R_CKCORE_TLS_GD32
4936 || howto->type == R_CKCORE_TLS_LDO32
4937 || howto->type == R_CKCORE_RELATIVE))
4938 need_reverse_bits = 0;
4939 else
4940 need_reverse_bits = 1;
4941 /* Do the final link. */
4942 if (howto->type != R_CKCORE_PCREL_JSR_IMM11BY2
4943 && howto->type != R_CKCORE_PCREL_JSR_IMM26BY2
4944 && howto->type != R_CKCORE_CALLGRAPH
4945 && do_final_relocate)
4946 r = csky_final_link_relocate (howto, input_bfd, input_section,
4947 contents, rel->r_offset,
4948 relocation, addend);
4949
4950 if (r != bfd_reloc_ok)
4951 {
4952 ret = FALSE;
4953 switch (r)
4954 {
4955 default:
4956 break;
4957 case bfd_reloc_overflow:
4958 if (h != NULL)
4959 name = NULL;
4960 else
4961 {
4962 name = bfd_elf_string_from_elf_section (input_bfd,
4963 symtab_hdr->sh_link,
4964 sym->st_name);
4965 if (name == NULL)
4966 break;
4967 if (*name == '\0')
fd361982 4968 name = bfd_section_name (sec);
b8891f8d
AJ		 4969 }
4970 (*info->callbacks->reloc_overflow)
4971 (info,
4972 (h ? &h->root : NULL),
4973 name, howto->name, (bfd_vma) 0,
4974 input_bfd, input_section, rel->r_offset);
4975 break;
4976 }
4977 }
4978 } /* End for (;rel < relend; rel++). */
4979 return ret;
4980}
4981
4982static bfd_boolean
4983csky_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
4984{
4985 int offset;
4986 size_t size;
4987
4988 switch (note->descsz)
4989 {
4990 default:
4991 return FALSE;
4992 /* Sizeof (struct elf_prstatus) on C-SKY V1 arch. */
4993 case 148:
4994 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
4995 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
4996 offset = 72;
4997 size = 72;
4998 break;
4999 /* Sizeof (struct elf_prstatus) on C-SKY V1 arch. */
5000 case 220:
5001 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
5002 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
5003 offset = 72;
5004 size = 34 * 4;
5005 break;
5006 }
5007 /* Make a ".reg/999" section. */
5008 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
5009 size, note->descpos + offset);
5010}
5011
5012static bfd_boolean
5013csky_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
5014{
5015 switch (note->descsz)
5016 {
5017 default:
5018 return FALSE;
5019
5020 /* Sizeof (struct elf_prpsinfo) on linux csky. */
5021 case 124:
5022 elf_tdata (abfd)->core->program
5023 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
5024 elf_tdata (abfd)->core->command
5025 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
5026 }
5027
5028 /* Note that for some reason, a spurious space is tacked
5029 onto the end of the args in some (at least one anyway)
5030 implementations, so strip it off if it exists. */
5031 {
5032 char *command = elf_tdata (abfd)->core->command;
5033 int n = strlen (command);
5034
5035 if (0 < n && command[n - 1] == ' ')
5036 command[n - 1] = '\0';
5037 }
5038
5039 return TRUE;
5040}
5041
5042/* End of external entry points for sizing and building linker stubs. */
5043
5044/* CPU-related basic API. */
5045#define TARGET_BIG_SYM csky_elf32_be_vec
5046#define TARGET_BIG_NAME "elf32-csky-big"
5047#define TARGET_LITTLE_SYM csky_elf32_le_vec
5048#define TARGET_LITTLE_NAME "elf32-csky-little"
5049#define ELF_ARCH bfd_arch_csky
5050#define ELF_MACHINE_CODE EM_CSKY
5051#define ELF_MACHINE_ALT1 EM_CSKY_OLD
5052#define ELF_MAXPAGESIZE 0x1000
5053#define elf_info_to_howto csky_elf_info_to_howto
5054#define elf_info_to_howto_rel NULL
5055#define elf_backend_special_sections csky_elf_special_sections
5056#define bfd_elf32_bfd_link_hash_table_create csky_elf_link_hash_table_create
5057
5058/* Target related API. */
5059#define bfd_elf32_mkobject csky_elf_mkobject
5060#define bfd_elf32_bfd_merge_private_bfd_data csky_elf_merge_private_bfd_data
5061#define bfd_elf32_bfd_set_private_flags csky_elf_set_private_flags
5062#define elf_backend_copy_indirect_symbol csky_elf_copy_indirect_symbol
5063
5064/* GC section related API. */
5065#define elf_backend_can_gc_sections 1
5066#define elf_backend_gc_mark_hook csky_elf_gc_mark_hook
5067#define elf_backend_gc_mark_extra_sections elf32_csky_gc_mark_extra_sections
5068
5069/* Relocation related API. */
5070#define elf_backend_reloc_type_class csky_elf_reloc_type_class
5071#define bfd_elf32_bfd_reloc_type_lookup csky_elf_reloc_type_lookup
5072#define bfd_elf32_bfd_reloc_name_lookup csky_elf_reloc_name_lookup
5073#define elf_backend_ignore_discarded_relocs csky_elf_ignore_discarded_relocs
5074#define elf_backend_relocate_section csky_elf_relocate_section
5075#define elf_backend_check_relocs csky_elf_check_relocs
5076
5077/* Dynamic relocate related API. */
5078#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
5079#define elf_backend_adjust_dynamic_symbol csky_elf_adjust_dynamic_symbol
5080#define elf_backend_size_dynamic_sections csky_elf_size_dynamic_sections
5081#define elf_backend_finish_dynamic_symbol csky_elf_finish_dynamic_symbol
5082#define elf_backend_finish_dynamic_sections csky_elf_finish_dynamic_sections
5083#define elf_backend_rela_normal 1
5084#define elf_backend_can_refcount 1
5085#define elf_backend_plt_readonly 1
5086#define elf_backend_want_got_sym 1
5087#define elf_backend_want_dynrelro 1
5088#define elf_backend_got_header_size 12
5089#define elf_backend_want_got_plt 1
5090
5091/* C-SKY coredump support. */
5092#define elf_backend_grok_prstatus csky_elf_grok_prstatus
5093#define elf_backend_grok_psinfo csky_elf_grok_psinfo
5094
5095#include "elf32-target.h"
A mirror of the official binutils-gdb repository