?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bfd/
[binutils.git] / bfd / elf32-bfin.c
blobf13a557631e86bac605c13c61741d77fe3253d57
1 /* ADI Blackfin BFD support for 32-bit ELF.
2 Copyright 2005, 2006, 2007 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "elf/bfin.h"
26 #include "elf/dwarf2.h"
27 #include "hashtab.h"
28
29 /* FUNCTION : bfin_pltpc_reloc
30 ABSTRACT : TODO : figure out how to handle pltpc relocs. */
31 static bfd_reloc_status_type
32 bfin_pltpc_reloc (
33 bfd *abfd ATTRIBUTE_UNUSED,
34 arelent *reloc_entry ATTRIBUTE_UNUSED,
35 asymbol *symbol ATTRIBUTE_UNUSED,
36 PTR data ATTRIBUTE_UNUSED,
37 asection *input_section ATTRIBUTE_UNUSED,
38 bfd *output_bfd ATTRIBUTE_UNUSED,
39 char **error_message ATTRIBUTE_UNUSED)
40 {
41 bfd_reloc_status_type flag = bfd_reloc_ok;
42 return flag;
43 }
44 \f
45
46 static bfd_reloc_status_type
47 bfin_pcrel24_reloc (bfd *abfd,
48 arelent *reloc_entry,
49 asymbol *symbol,
50 PTR data,
51 asection *input_section,
52 bfd *output_bfd,
53 char **error_message ATTRIBUTE_UNUSED)
54 {
55 bfd_vma relocation;
56 bfd_size_type addr = reloc_entry->address;
57 bfd_vma output_base = 0;
58 reloc_howto_type *howto = reloc_entry->howto;
59 asection *output_section;
60 bfd_boolean relocatable = (output_bfd != NULL);
61
62 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
63 return bfd_reloc_outofrange;
64
65 if (bfd_is_und_section (symbol->section)
66 && (symbol->flags & BSF_WEAK) == 0
67 && !relocatable)
68 return bfd_reloc_undefined;
69
70 if (bfd_is_com_section (symbol->section))
71 relocation = 0;
72 else
73 relocation = symbol->value;
74
75 output_section = symbol->section->output_section;
76
77 if (relocatable)
78 output_base = 0;
79 else
80 output_base = output_section->vma;
81
82 if (!relocatable || !strcmp (symbol->name, symbol->section->name))
83 relocation += output_base + symbol->section->output_offset;
84
85 if (!relocatable && !strcmp (symbol->name, symbol->section->name))
86 relocation += reloc_entry->addend;
87
88 relocation -= input_section->output_section->vma + input_section->output_offset;
89 relocation -= reloc_entry->address;
90
91 if (howto->complain_on_overflow != complain_overflow_dont)
92 {
93 bfd_reloc_status_type status;
94 status = bfd_check_overflow (howto->complain_on_overflow,
95 howto->bitsize,
96 howto->rightshift,
97 bfd_arch_bits_per_address(abfd),
98 relocation);
99 if (status != bfd_reloc_ok)
100 return status;
101 }
102
103 /* if rightshift is 1 and the number odd, return error. */
104 if (howto->rightshift && (relocation & 0x01))
105 {
106 fprintf(stderr, "relocation should be even number\n");
107 return bfd_reloc_overflow;
108 }
109
110 relocation >>= (bfd_vma) howto->rightshift;
111 /* Shift everything up to where it's going to be used. */
112
113 relocation <<= (bfd_vma) howto->bitpos;
114
115 if (relocatable)
116 {
117 reloc_entry->address += input_section->output_offset;
118 reloc_entry->addend += symbol->section->output_offset;
119 }
120
121 {
122 short x;
123
124 /* We are getting reloc_entry->address 2 byte off from
125 the start of instruction. Assuming absolute postion
126 of the reloc data. But, following code had been written assuming
127 reloc address is starting at begining of instruction.
128 To compensate that I have increased the value of
129 relocation by 1 (effectively 2) and used the addr -2 instead of addr. */
130
131 relocation += 1;
132 x = bfd_get_16 (abfd, (bfd_byte *) data + addr - 2);
133 x = (x & 0xff00) | ((relocation >> 16) & 0xff);
134 bfd_put_16 (abfd, x, (unsigned char *) data + addr - 2);
135
136 x = bfd_get_16 (abfd, (bfd_byte *) data + addr);
137 x = relocation & 0xFFFF;
138 bfd_put_16 (abfd, x, (unsigned char *) data + addr );
139 }
140 return bfd_reloc_ok;
141 }
142
143 static bfd_reloc_status_type
144 bfin_imm16_reloc (bfd *abfd,
145 arelent *reloc_entry,
146 asymbol *symbol,
147 PTR data,
148 asection *input_section,
149 bfd *output_bfd,
150 char **error_message ATTRIBUTE_UNUSED)
151 {
152 bfd_vma relocation, x;
153 bfd_size_type reloc_addr = reloc_entry->address;
154 bfd_vma output_base = 0;
155 reloc_howto_type *howto = reloc_entry->howto;
156 asection *output_section;
157 bfd_boolean relocatable = (output_bfd != NULL);
158
159 /* Is the address of the relocation really within the section? */
160 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
161 return bfd_reloc_outofrange;
162
163 if (bfd_is_und_section (symbol->section)
164 && (symbol->flags & BSF_WEAK) == 0
165 && !relocatable)
166 return bfd_reloc_undefined;
167
168 output_section = symbol->section->output_section;
169 relocation = symbol->value;
170
171 /* Convert input-section-relative symbol value to absolute. */
172 if (relocatable)
173 output_base = 0;
174 else
175 output_base = output_section->vma;
176
177 if (!relocatable || !strcmp (symbol->name, symbol->section->name))
178 relocation += output_base + symbol->section->output_offset;
179
180 /* Add in supplied addend. */
181 relocation += reloc_entry->addend;
182
183 if (relocatable)
184 {
185 reloc_entry->address += input_section->output_offset;
186 reloc_entry->addend += symbol->section->output_offset;
187 }
188 else
189 {
190 reloc_entry->addend = 0;
191 }
192
193 if (howto->complain_on_overflow != complain_overflow_dont)
194 {
195 bfd_reloc_status_type flag;
196 flag = bfd_check_overflow (howto->complain_on_overflow,
197 howto->bitsize,
198 howto->rightshift,
199 bfd_arch_bits_per_address(abfd),
200 relocation);
201 if (flag != bfd_reloc_ok)
202 return flag;
203 }
204
205 /* Here the variable relocation holds the final address of the
206 symbol we are relocating against, plus any addend. */
207
208 relocation >>= (bfd_vma) howto->rightshift;
209 x = relocation;
210 bfd_put_16 (abfd, x, (unsigned char *) data + reloc_addr);
211 return bfd_reloc_ok;
212 }
213
214
215 static bfd_reloc_status_type
216 bfin_byte4_reloc (bfd *abfd,
217 arelent *reloc_entry,
218 asymbol *symbol,
219 PTR data,
220 asection *input_section,
221 bfd *output_bfd,
222 char **error_message ATTRIBUTE_UNUSED)
223 {
224 bfd_vma relocation, x;
225 bfd_size_type addr = reloc_entry->address;
226 bfd_vma output_base = 0;
227 asection *output_section;
228 bfd_boolean relocatable = (output_bfd != NULL);
229
230 /* Is the address of the relocation really within the section? */
231 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
232 return bfd_reloc_outofrange;
233
234 if (bfd_is_und_section (symbol->section)
235 && (symbol->flags & BSF_WEAK) == 0
236 && !relocatable)
237 return bfd_reloc_undefined;
238
239 output_section = symbol->section->output_section;
240 relocation = symbol->value;
241 /* Convert input-section-relative symbol value to absolute. */
242 if (relocatable)
243 output_base = 0;
244 else
245 output_base = output_section->vma;
246
247 if ((symbol->name
248 && symbol->section->name
249 && !strcmp (symbol->name, symbol->section->name))
250 || !relocatable)
251 {
252 relocation += output_base + symbol->section->output_offset;
253 }
254
255 relocation += reloc_entry->addend;
256
257 if (relocatable)
258 {
259 /* This output will be relocatable ... like ld -r. */
260 reloc_entry->address += input_section->output_offset;
261 reloc_entry->addend += symbol->section->output_offset;
262 }
263 else
264 {
265 reloc_entry->addend = 0;
266 }
267
268 /* Here the variable relocation holds the final address of the
269 symbol we are relocating against, plus any addend. */
270 x = relocation & 0xFFFF0000;
271 x >>=16;
272 bfd_put_16 (abfd, x, (unsigned char *) data + addr + 2);
273
274 x = relocation & 0x0000FFFF;
275 bfd_put_16 (abfd, x, (unsigned char *) data + addr);
276 return bfd_reloc_ok;
277 }
278
279 /* bfin_bfd_reloc handles the blackfin arithmetic relocations.
280 Use this instead of bfd_perform_relocation. */
281 static bfd_reloc_status_type
282 bfin_bfd_reloc (bfd *abfd,
283 arelent *reloc_entry,
284 asymbol *symbol,
285 PTR data,
286 asection *input_section,
287 bfd *output_bfd,
288 char **error_message ATTRIBUTE_UNUSED)
289 {
290 bfd_vma relocation;
291 bfd_size_type addr = reloc_entry->address;
292 bfd_vma output_base = 0;
293 reloc_howto_type *howto = reloc_entry->howto;
294 asection *output_section;
295 bfd_boolean relocatable = (output_bfd != NULL);
296
297 /* Is the address of the relocation really within the section? */
298 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
299 return bfd_reloc_outofrange;
300
301 if (bfd_is_und_section (symbol->section)
302 && (symbol->flags & BSF_WEAK) == 0
303 && !relocatable)
304 return bfd_reloc_undefined;
305
306 /* Get symbol value. (Common symbols are special.) */
307 if (bfd_is_com_section (symbol->section))
308 relocation = 0;
309 else
310 relocation = symbol->value;
311
312 output_section = symbol->section->output_section;
313
314 /* Convert input-section-relative symbol value to absolute. */
315 if (relocatable)
316 output_base = 0;
317 else
318 output_base = output_section->vma;
319
320 if (!relocatable || !strcmp (symbol->name, symbol->section->name))
321 relocation += output_base + symbol->section->output_offset;
322
323 if (!relocatable && !strcmp (symbol->name, symbol->section->name))
324 {
325 /* Add in supplied addend. */
326 relocation += reloc_entry->addend;
327 }
328
329 /* Here the variable relocation holds the final address of the
330 symbol we are relocating against, plus any addend. */
331
332 if (howto->pc_relative == TRUE)
333 {
334 relocation -= input_section->output_section->vma + input_section->output_offset;
335
336 if (howto->pcrel_offset == TRUE)
337 relocation -= reloc_entry->address;
338 }
339
340 if (relocatable)
341 {
342 reloc_entry->address += input_section->output_offset;
343 reloc_entry->addend += symbol->section->output_offset;
344 }
345
346 if (howto->complain_on_overflow != complain_overflow_dont)
347 {
348 bfd_reloc_status_type status;
349
350 status = bfd_check_overflow (howto->complain_on_overflow,
351 howto->bitsize,
352 howto->rightshift,
353 bfd_arch_bits_per_address(abfd),
354 relocation);
355 if (status != bfd_reloc_ok)
356 return status;
357 }
358
359 /* If rightshift is 1 and the number odd, return error. */
360 if (howto->rightshift && (relocation & 0x01))
361 {
362 fprintf(stderr, "relocation should be even number\n");
363 return bfd_reloc_overflow;
364 }
365
366 relocation >>= (bfd_vma) howto->rightshift;
367
368 /* Shift everything up to where it's going to be used. */
369
370 relocation <<= (bfd_vma) howto->bitpos;
371
372 #define DOIT(x) \
373 x = ( (x & ~howto->dst_mask) | (relocation & howto->dst_mask))
374
375 /* handle 8 and 16 bit relocations here. */
376 switch (howto->size)
377 {
378 case 0:
379 {
380 char x = bfd_get_8 (abfd, (char *) data + addr);
381 DOIT (x);
382 bfd_put_8 (abfd, x, (unsigned char *) data + addr);
383 }
384 break;
385
386 case 1:
387 {
388 unsigned short x = bfd_get_16 (abfd, (bfd_byte *) data + addr);
389 DOIT (x);
390 bfd_put_16 (abfd, (bfd_vma) x, (unsigned char *) data + addr);
391 }
392 break;
393
394 default:
395 return bfd_reloc_other;
396 }
397
398 return bfd_reloc_ok;
399 }
400
401 /* HOWTO Table for blackfin.
402 Blackfin relocations are fairly complicated.
403 Some of the salient features are
404 a. Even numbered offsets. A number of (not all) relocations are
405 even numbered. This means that the rightmost bit is not stored.
406 Needs to right shift by 1 and check to see if value is not odd
407 b. A relocation can be an expression. An expression takes on
408 a variety of relocations arranged in a stack.
409 As a result, we cannot use the standard generic function as special
410 function. We will have our own, which is very similar to the standard
411 generic function except that it understands how to get the value from
412 the relocation stack. . */
413
414 #define BFIN_RELOC_MIN 0
415 #define BFIN_RELOC_MAX 0x21
416 #define BFIN_GNUEXT_RELOC_MIN 0x40
417 #define BFIN_GNUEXT_RELOC_MAX 0x43
418 #define BFIN_ARELOC_MIN 0xE0
419 #define BFIN_ARELOC_MAX 0xF3
420
421 static reloc_howto_type bfin_howto_table [] =
422 {
423 /* This reloc does nothing. . */
424 HOWTO (R_unused0, /* type. */
425 0, /* rightshift. */
426 2, /* size (0 = byte, 1 = short, 2 = long). */
427 32, /* bitsize. */
428 FALSE, /* pc_relative. */
429 0, /* bitpos. */
430 complain_overflow_bitfield, /* complain_on_overflow. */
431 bfd_elf_generic_reloc, /* special_function. */
432 "R_unused0", /* name. */
433 FALSE, /* partial_inplace. */
434 0, /* src_mask. */
435 0, /* dst_mask. */
436 FALSE), /* pcrel_offset. */
437
438 HOWTO (R_pcrel5m2, /* type. */
439 1, /* rightshift. */
440 1, /* size (0 = byte, 1 = short, 2 = long).. */
441 4, /* bitsize. */
442 TRUE, /* pc_relative. */
443 0, /* bitpos. */
444 complain_overflow_unsigned, /* complain_on_overflow. */
445 bfin_bfd_reloc, /* special_function. */
446 "R_pcrel5m2", /* name. */
447 FALSE, /* partial_inplace. */
448 0, /* src_mask. */
449 0x0000000F, /* dst_mask. */
450 FALSE), /* pcrel_offset. */
451
452 HOWTO (R_unused1, /* type. */
453 0, /* rightshift. */
454 2, /* size (0 = byte, 1 = short, 2 = long). */
455 32, /* bitsize. */
456 FALSE, /* pc_relative. */
457 0, /* bitpos. */
458 complain_overflow_bitfield, /* complain_on_overflow. */
459 bfd_elf_generic_reloc, /* special_function. */
460 "R_unused1", /* name. */
461 FALSE, /* partial_inplace. */
462 0, /* src_mask. */
463 0, /* dst_mask. */
464 FALSE), /* pcrel_offset. */
465
466 HOWTO (R_pcrel10, /* type. */
467 1, /* rightshift. */
468 1, /* size (0 = byte, 1 = short, 2 = long). */
469 10, /* bitsize. */
470 TRUE, /* pc_relative. */
471 0, /* bitpos. */
472 complain_overflow_signed, /* complain_on_overflow. */
473 bfin_bfd_reloc, /* special_function. */
474 "R_pcrel10", /* name. */
475 FALSE, /* partial_inplace. */
476 0, /* src_mask. */
477 0x000003FF, /* dst_mask. */
478 TRUE), /* pcrel_offset. */
479
480 HOWTO (R_pcrel12_jump, /* type. */
481 1, /* rightshift. */
482 /* the offset is actually 13 bit
483 aligned on a word boundary so
484 only 12 bits have to be used.
485 Right shift the rightmost bit.. */
486 1, /* size (0 = byte, 1 = short, 2 = long). */
487 12, /* bitsize. */
488 TRUE, /* pc_relative. */
489 0, /* bitpos. */
490 complain_overflow_signed, /* complain_on_overflow. */
491 bfin_bfd_reloc, /* special_function. */
492 "R_pcrel12_jump", /* name. */
493 FALSE, /* partial_inplace. */
494 0, /* src_mask. */
495 0x0FFF, /* dst_mask. */
496 TRUE), /* pcrel_offset. */
497
498 HOWTO (R_rimm16, /* type. */
499 0, /* rightshift. */
500 1, /* size (0 = byte, 1 = short, 2 = long). */
501 16, /* bitsize. */
502 FALSE, /* pc_relative. */
503 0, /* bitpos. */
504 complain_overflow_signed, /* complain_on_overflow. */
505 bfin_imm16_reloc, /* special_function. */
506 "R_rimm16", /* name. */
507 FALSE, /* partial_inplace. */
508 0, /* src_mask. */
509 0x0000FFFF, /* dst_mask. */
510 TRUE), /* pcrel_offset. */
511
512 HOWTO (R_luimm16, /* type. */
513 0, /* rightshift. */
514 1, /* size (0 = byte, 1 = short, 2 = long). */
515 16, /* bitsize. */
516 FALSE, /* pc_relative. */
517 0, /* bitpos. */
518 complain_overflow_dont, /* complain_on_overflow. */
519 bfin_imm16_reloc, /* special_function. */
520 "R_luimm16", /* name. */
521 FALSE, /* partial_inplace. */
522 0, /* src_mask. */
523 0x0000FFFF, /* dst_mask. */
524 TRUE), /* pcrel_offset. */
525
526 HOWTO (R_huimm16, /* type. */
527 16, /* rightshift. */
528 1, /* size (0 = byte, 1 = short, 2 = long). */
529 16, /* bitsize. */
530 FALSE, /* pc_relative. */
531 0, /* bitpos. */
532 complain_overflow_unsigned, /* complain_on_overflow. */
533 bfin_imm16_reloc, /* special_function. */
534 "R_huimm16", /* name. */
535 FALSE, /* partial_inplace. */
536 0, /* src_mask. */
537 0x0000FFFF, /* dst_mask. */
538 TRUE), /* pcrel_offset. */
539
540 HOWTO (R_pcrel12_jump_s, /* type. */
541 1, /* rightshift. */
542 1, /* size (0 = byte, 1 = short, 2 = long). */
543 12, /* bitsize. */
544 TRUE, /* pc_relative. */
545 0, /* bitpos. */
546 complain_overflow_signed, /* complain_on_overflow. */
547 bfin_bfd_reloc, /* special_function. */
548 "R_pcrel12_jump_s", /* name. */
549 FALSE, /* partial_inplace. */
550 0, /* src_mask. */
551 0x00000FFF, /* dst_mask. */
552 TRUE), /* pcrel_offset. */
553
554 HOWTO (R_pcrel24_jump_x, /* type. */
555 1, /* rightshift. */
556 2, /* size (0 = byte, 1 = short, 2 = long). */
557 24, /* bitsize. */
558 TRUE, /* pc_relative. */
559 0, /* bitpos. */
560 complain_overflow_signed, /* complain_on_overflow. */
561 bfin_pcrel24_reloc, /* special_function. */
562 "R_pcrel24_jump_x", /* name. */
563 FALSE, /* partial_inplace. */
564 0, /* src_mask. */
565 0x00FFFFFF, /* dst_mask. */
566 TRUE), /* pcrel_offset. */
567
568 HOWTO (R_pcrel24, /* type. */
569 1, /* rightshift. */
570 2, /* size (0 = byte, 1 = short, 2 = long). */
571 24, /* bitsize. */
572 TRUE, /* pc_relative. */
573 0, /* bitpos. */
574 complain_overflow_signed, /* complain_on_overflow. */
575 bfin_pcrel24_reloc, /* special_function. */
576 "R_pcrel24", /* name. */
577 FALSE, /* partial_inplace. */
578 0, /* src_mask. */
579 0x00FFFFFF, /* dst_mask. */
580 TRUE), /* pcrel_offset. */
581
582 HOWTO (R_unusedb, /* type. */
583 0, /* rightshift. */
584 2, /* size (0 = byte, 1 = short, 2 = long). */
585 32, /* bitsize. */
586 FALSE, /* pc_relative. */
587 0, /* bitpos. */
588 complain_overflow_dont, /* complain_on_overflow. */
589 bfd_elf_generic_reloc, /* special_function. */
590 "R_unusedb", /* name. */
591 FALSE, /* partial_inplace. */
592 0, /* src_mask. */
593 0, /* dst_mask. */
594 FALSE), /* pcrel_offset. */
595
596 HOWTO (R_unusedc, /* type. */
597 0, /* rightshift. */
598 2, /* size (0 = byte, 1 = short, 2 = long). */
599 32, /* bitsize. */
600 FALSE, /* pc_relative. */
601 0, /* bitpos. */
602 complain_overflow_dont, /* complain_on_overflow. */
603 bfd_elf_generic_reloc, /* special_function. */
604 "R_unusedc", /* name. */
605 FALSE, /* partial_inplace. */
606 0, /* src_mask. */
607 0, /* dst_mask. */
608 FALSE), /* pcrel_offset. */
609
610 HOWTO (R_pcrel24_jump_l, /* type. */
611 1, /* rightshift. */
612 2, /* size (0 = byte, 1 = short, 2 = long). */
613 24, /* bitsize. */
614 TRUE, /* pc_relative. */
615 0, /* bitpos. */
616 complain_overflow_signed, /* complain_on_overflow. */
617 bfin_pcrel24_reloc, /* special_function. */
618 "R_pcrel24_jump_l", /* name. */
619 FALSE, /* partial_inplace. */
620 0, /* src_mask. */
621 0x00FFFFFF, /* dst_mask. */
622 TRUE), /* pcrel_offset. */
623
624 HOWTO (R_pcrel24_call_x, /* type. */
625 1, /* rightshift. */
626 2, /* size (0 = byte, 1 = short, 2 = long). */
627 24, /* bitsize. */
628 TRUE, /* pc_relative. */
629 0, /* bitpos. */
630 complain_overflow_signed, /* complain_on_overflow. */
631 bfin_pcrel24_reloc, /* special_function. */
632 "R_pcrel24_call_x", /* name. */
633 FALSE, /* partial_inplace. */
634 0, /* src_mask. */
635 0x00FFFFFF, /* dst_mask. */
636 TRUE), /* pcrel_offset. */
637
638 HOWTO (R_var_eq_symb, /* type. */
639 0, /* rightshift. */
640 2, /* size (0 = byte, 1 = short, 2 = long). */
641 32, /* bitsize. */
642 FALSE, /* pc_relative. */
643 0, /* bitpos. */
644 complain_overflow_bitfield, /* complain_on_overflow. */
645 bfin_bfd_reloc, /* special_function. */
646 "R_var_eq_symb", /* name. */
647 FALSE, /* partial_inplace. */
648 0, /* src_mask. */
649 0, /* dst_mask. */
650 FALSE), /* pcrel_offset. */
651
652 HOWTO (R_byte_data, /* type. */
653 0, /* rightshift. */
654 0, /* size (0 = byte, 1 = short, 2 = long). */
655 8, /* bitsize. */
656 FALSE, /* pc_relative. */
657 0, /* bitpos. */
658 complain_overflow_unsigned, /* complain_on_overflow. */
659 bfin_bfd_reloc, /* special_function. */
660 "R_byte_data", /* name. */
661 FALSE, /* partial_inplace. */
662 0, /* src_mask. */
663 0xFF, /* dst_mask. */
664 TRUE), /* pcrel_offset. */
665
666 HOWTO (R_byte2_data, /* type. */
667 0, /* rightshift. */
668 1, /* size (0 = byte, 1 = short, 2 = long). */
669 16, /* bitsize. */
670 FALSE, /* pc_relative. */
671 0, /* bitpos. */
672 complain_overflow_signed, /* complain_on_overflow. */
673 bfin_bfd_reloc, /* special_function. */
674 "R_byte2_data", /* name. */
675 FALSE, /* partial_inplace. */
676 0, /* src_mask. */
677 0xFFFF, /* dst_mask. */
678 TRUE), /* pcrel_offset. */
679
680 HOWTO (R_byte4_data, /* type. */
681 0, /* rightshift. */
682 2, /* size (0 = byte, 1 = short, 2 = long). */
683 32, /* bitsize. */
684 FALSE, /* pc_relative. */
685 0, /* bitpos. */
686 complain_overflow_unsigned, /* complain_on_overflow. */
687 bfin_byte4_reloc, /* special_function. */
688 "R_byte4_data", /* name. */
689 FALSE, /* partial_inplace. */
690 0, /* src_mask. */
691 0xFFFFFFFF, /* dst_mask. */
692 TRUE), /* pcrel_offset. */
693
694 HOWTO (R_pcrel11, /* type. */
695 1, /* rightshift. */
696 1, /* size (0 = byte, 1 = short, 2 = long). */
697 10, /* bitsize. */
698 TRUE, /* pc_relative. */
699 0, /* bitpos. */
700 complain_overflow_unsigned, /* complain_on_overflow. */
701 bfin_bfd_reloc, /* special_function. */
702 "R_pcrel11", /* name. */
703 FALSE, /* partial_inplace. */
704 0, /* src_mask. */
705 0x000003FF, /* dst_mask. */
706 FALSE), /* pcrel_offset. */
707
708
709 /* A 18-bit signed operand with the GOT offset for the address of
710 the symbol. */
711 HOWTO (R_BFIN_GOT17M4, /* type */
712 2, /* rightshift */
713 1, /* size (0 = byte, 1 = short, 2 = long) */
714 16, /* bitsize */
715 FALSE, /* pc_relative */
716 0, /* bitpos */
717 complain_overflow_signed, /* complain_on_overflow */
718 bfd_elf_generic_reloc, /* special_function */
719 "R_BFIN_GOT17M4", /* name */
720 FALSE, /* partial_inplace */
721 0xffff, /* src_mask */
722 0xffff, /* dst_mask */
723 FALSE), /* pcrel_offset */
724
725 /* The upper 16 bits of the GOT offset for the address of the
726 symbol. */
727 HOWTO (R_BFIN_GOTHI, /* type */
728 0, /* rightshift */
729 1, /* size (0 = byte, 1 = short, 2 = long) */
730 16, /* bitsize */
731 FALSE, /* pc_relative */
732 0, /* bitpos */
733 complain_overflow_dont, /* complain_on_overflow */
734 bfd_elf_generic_reloc, /* special_function */
735 "R_BFIN_GOTHI", /* name */
736 FALSE, /* partial_inplace */
737 0xffff, /* src_mask */
738 0xffff, /* dst_mask */
739 FALSE), /* pcrel_offset */
740
741 /* The lower 16 bits of the GOT offset for the address of the
742 symbol. */
743 HOWTO (R_BFIN_GOTLO, /* type */
744 0, /* rightshift */
745 1, /* size (0 = byte, 1 = short, 2 = long) */
746 16, /* bitsize */
747 FALSE, /* pc_relative */
748 0, /* bitpos */
749 complain_overflow_dont, /* complain_on_overflow */
750 bfd_elf_generic_reloc, /* special_function */
751 "R_BFIN_GOTLO", /* name */
752 FALSE, /* partial_inplace */
753 0xffff, /* src_mask */
754 0xffff, /* dst_mask */
755 FALSE), /* pcrel_offset */
756
757 /* The 32-bit address of the canonical descriptor of a function. */
758 HOWTO (R_BFIN_FUNCDESC, /* type */
759 0, /* rightshift */
760 2, /* size (0 = byte, 1 = short, 2 = long) */
761 32, /* bitsize */
762 FALSE, /* pc_relative */
763 0, /* bitpos */
764 complain_overflow_bitfield, /* complain_on_overflow */
765 bfd_elf_generic_reloc, /* special_function */
766 "R_BFIN_FUNCDESC", /* name */
767 FALSE, /* partial_inplace */
768 0xffffffff, /* src_mask */
769 0xffffffff, /* dst_mask */
770 FALSE), /* pcrel_offset */
771
772 /* A 12-bit signed operand with the GOT offset for the address of
773 canonical descriptor of a function. */
774 HOWTO (R_BFIN_FUNCDESC_GOT17M4, /* type */
775 2, /* rightshift */
776 1, /* size (0 = byte, 1 = short, 2 = long) */
777 16, /* bitsize */
778 FALSE, /* pc_relative */
779 0, /* bitpos */
780 complain_overflow_signed, /* complain_on_overflow */
781 bfd_elf_generic_reloc, /* special_function */
782 "R_BFIN_FUNCDESC_GOT17M4", /* name */
783 FALSE, /* partial_inplace */
784 0xffff, /* src_mask */
785 0xffff, /* dst_mask */
786 FALSE), /* pcrel_offset */
787
788 /* The upper 16 bits of the GOT offset for the address of the
789 canonical descriptor of a function. */
790 HOWTO (R_BFIN_FUNCDESC_GOTHI, /* type */
791 0, /* rightshift */
792 1, /* size (0 = byte, 1 = short, 2 = long) */
793 16, /* bitsize */
794 FALSE, /* pc_relative */
795 0, /* bitpos */
796 complain_overflow_dont, /* complain_on_overflow */
797 bfd_elf_generic_reloc, /* special_function */
798 "R_BFIN_FUNCDESC_GOTHI", /* name */
799 FALSE, /* partial_inplace */
800 0xffff, /* src_mask */
801 0xffff, /* dst_mask */
802 FALSE), /* pcrel_offset */
803
804 /* The lower 16 bits of the GOT offset for the address of the
805 canonical descriptor of a function. */
806 HOWTO (R_BFIN_FUNCDESC_GOTLO, /* type */
807 0, /* rightshift */
808 1, /* size (0 = byte, 1 = short, 2 = long) */
809 16, /* bitsize */
810 FALSE, /* pc_relative */
811 0, /* bitpos */
812 complain_overflow_dont, /* complain_on_overflow */
813 bfd_elf_generic_reloc, /* special_function */
814 "R_BFIN_FUNCDESC_GOTLO", /* name */
815 FALSE, /* partial_inplace */
816 0xffff, /* src_mask */
817 0xffff, /* dst_mask */
818 FALSE), /* pcrel_offset */
819
820 /* The 32-bit address of the canonical descriptor of a function. */
821 HOWTO (R_BFIN_FUNCDESC_VALUE, /* type */
822 0, /* rightshift */
823 2, /* size (0 = byte, 1 = short, 2 = long) */
824 64, /* bitsize */
825 FALSE, /* pc_relative */
826 0, /* bitpos */
827 complain_overflow_bitfield, /* complain_on_overflow */
828 bfd_elf_generic_reloc, /* special_function */
829 "R_BFIN_FUNCDESC_VALUE", /* name */
830 FALSE, /* partial_inplace */
831 0xffffffff, /* src_mask */
832 0xffffffff, /* dst_mask */
833 FALSE), /* pcrel_offset */
834
835 /* A 12-bit signed operand with the GOT offset for the address of
836 canonical descriptor of a function. */
837 HOWTO (R_BFIN_FUNCDESC_GOTOFF17M4, /* type */
838 2, /* rightshift */
839 1, /* size (0 = byte, 1 = short, 2 = long) */
840 16, /* bitsize */
841 FALSE, /* pc_relative */
842 0, /* bitpos */
843 complain_overflow_signed, /* complain_on_overflow */
844 bfd_elf_generic_reloc, /* special_function */
845 "R_BFIN_FUNCDESC_GOTOFF17M4", /* name */
846 FALSE, /* partial_inplace */
847 0xffff, /* src_mask */
848 0xffff, /* dst_mask */
849 FALSE), /* pcrel_offset */
850
851 /* The upper 16 bits of the GOT offset for the address of the
852 canonical descriptor of a function. */
853 HOWTO (R_BFIN_FUNCDESC_GOTOFFHI, /* type */
854 0, /* rightshift */
855 1, /* size (0 = byte, 1 = short, 2 = long) */
856 16, /* bitsize */
857 FALSE, /* pc_relative */
858 0, /* bitpos */
859 complain_overflow_dont, /* complain_on_overflow */
860 bfd_elf_generic_reloc, /* special_function */
861 "R_BFIN_FUNCDESC_GOTOFFHI", /* name */
862 FALSE, /* partial_inplace */
863 0xffff, /* src_mask */
864 0xffff, /* dst_mask */
865 FALSE), /* pcrel_offset */
866
867 /* The lower 16 bits of the GOT offset for the address of the
868 canonical descriptor of a function. */
869 HOWTO (R_BFIN_FUNCDESC_GOTOFFLO, /* type */
870 0, /* rightshift */
871 1, /* size (0 = byte, 1 = short, 2 = long) */
872 16, /* bitsize */
873 FALSE, /* pc_relative */
874 0, /* bitpos */
875 complain_overflow_dont, /* complain_on_overflow */
876 bfd_elf_generic_reloc, /* special_function */
877 "R_BFIN_FUNCDESC_GOTOFFLO", /* name */
878 FALSE, /* partial_inplace */
879 0xffff, /* src_mask */
880 0xffff, /* dst_mask */
881 FALSE), /* pcrel_offset */
882
883 /* A 12-bit signed operand with the GOT offset for the address of
884 the symbol. */
885 HOWTO (R_BFIN_GOTOFF17M4, /* type */
886 2, /* rightshift */
887 1, /* size (0 = byte, 1 = short, 2 = long) */
888 16, /* bitsize */
889 FALSE, /* pc_relative */
890 0, /* bitpos */
891 complain_overflow_signed, /* complain_on_overflow */
892 bfd_elf_generic_reloc, /* special_function */
893 "R_BFIN_GOTOFF17M4", /* name */
894 FALSE, /* partial_inplace */
895 0xffff, /* src_mask */
896 0xffff, /* dst_mask */
897 FALSE), /* pcrel_offset */
898
899 /* The upper 16 bits of the GOT offset for the address of the
900 symbol. */
901 HOWTO (R_BFIN_GOTOFFHI, /* type */
902 0, /* rightshift */
903 1, /* size (0 = byte, 1 = short, 2 = long) */
904 16, /* bitsize */
905 FALSE, /* pc_relative */
906 0, /* bitpos */
907 complain_overflow_dont, /* complain_on_overflow */
908 bfd_elf_generic_reloc, /* special_function */
909 "R_BFIN_GOTOFFHI", /* name */
910 FALSE, /* partial_inplace */
911 0xffff, /* src_mask */
912 0xffff, /* dst_mask */
913 FALSE), /* pcrel_offset */
914
915 /* The lower 16 bits of the GOT offset for the address of the
916 symbol. */
917 HOWTO (R_BFIN_GOTOFFLO, /* type */
918 0, /* rightshift */
919 1, /* size (0 = byte, 1 = short, 2 = long) */
920 16, /* bitsize */
921 FALSE, /* pc_relative */
922 0, /* bitpos */
923 complain_overflow_dont, /* complain_on_overflow */
924 bfd_elf_generic_reloc, /* special_function */
925 "R_BFIN_GOTOFFLO", /* name */
926 FALSE, /* partial_inplace */
927 0xffff, /* src_mask */
928 0xffff, /* dst_mask */
929 FALSE), /* pcrel_offset */
930 };
931
932 static reloc_howto_type bfin_gnuext_howto_table [] =
933 {
934 HOWTO (R_pltpc, /* type. */
935 0, /* rightshift. */
936 1, /* size (0 = byte, 1 = short, 2 = long). */
937 16, /* bitsize. */
938 FALSE, /* pc_relative. */
939 0, /* bitpos. */
940 complain_overflow_bitfield, /* complain_on_overflow. */
941 bfin_pltpc_reloc, /* special_function. */
942 "R_pltpc", /* name. */
943 FALSE, /* partial_inplace. */
944 0xffff, /* src_mask. */
945 0xffff, /* dst_mask. */
946 FALSE), /* pcrel_offset. */
947
948 HOWTO (R_got, /* type. */
949 0, /* rightshift. */
950 1, /* size (0 = byte, 1 = short, 2 = long). */
951 16, /* bitsize. */
952 FALSE, /* pc_relative. */
953 0, /* bitpos. */
954 complain_overflow_bitfield, /* complain_on_overflow. */
955 bfd_elf_generic_reloc, /* special_function. */
956 "R_got", /* name. */
957 FALSE, /* partial_inplace. */
958 0x7fff, /* src_mask. */
959 0x7fff, /* dst_mask. */
960 FALSE), /* pcrel_offset. */
961
962 /* GNU extension to record C++ vtable hierarchy. */
963 HOWTO (R_BFIN_GNU_VTINHERIT, /* type. */
964 0, /* rightshift. */
965 2, /* size (0 = byte, 1 = short, 2 = long). */
966 0, /* bitsize. */
967 FALSE, /* pc_relative. */
968 0, /* bitpos. */
969 complain_overflow_dont, /* complain_on_overflow. */
970 NULL, /* special_function. */
971 "R_BFIN_GNU_VTINHERIT", /* name. */
972 FALSE, /* partial_inplace. */
973 0, /* src_mask. */
974 0, /* dst_mask. */
975 FALSE), /* pcrel_offset. */
976
977 /* GNU extension to record C++ vtable member usage. */
978 HOWTO (R_BFIN_GNU_VTENTRY, /* type. */
979 0, /* rightshift. */
980 2, /* size (0 = byte, 1 = short, 2 = long). */
981 0, /* bitsize. */
982 FALSE, /* pc_relative. */
983 0, /* bitpos. */
984 complain_overflow_dont, /* complain_on_overflow. */
985 _bfd_elf_rel_vtable_reloc_fn, /* special_function. */
986 "R_BFIN_GNU_VTENTRY", /* name. */
987 FALSE, /* partial_inplace. */
988 0, /* src_mask. */
989 0, /* dst_mask. */
990 FALSE) /* pcrel_offset. */
991 };
992
993 struct bfin_reloc_map
994 {
995 bfd_reloc_code_real_type bfd_reloc_val;
996 unsigned int bfin_reloc_val;
997 };
998
999 static const struct bfin_reloc_map bfin_reloc_map [] =
1000 {
1001 { BFD_RELOC_NONE, R_unused0 },
1002 { BFD_RELOC_BFIN_5_PCREL, R_pcrel5m2 },
1003 { BFD_RELOC_NONE, R_unused1 },
1004 { BFD_RELOC_BFIN_10_PCREL, R_pcrel10 },
1005 { BFD_RELOC_BFIN_12_PCREL_JUMP, R_pcrel12_jump },
1006 { BFD_RELOC_BFIN_16_IMM, R_rimm16 },
1007 { BFD_RELOC_BFIN_16_LOW, R_luimm16 },
1008 { BFD_RELOC_BFIN_16_HIGH, R_huimm16 },
1009 { BFD_RELOC_BFIN_12_PCREL_JUMP_S, R_pcrel12_jump_s },
1010 { BFD_RELOC_24_PCREL, R_pcrel24 },
1011 { BFD_RELOC_24_PCREL, R_pcrel24 },
1012 { BFD_RELOC_BFIN_24_PCREL_JUMP_L, R_pcrel24_jump_l },
1013 { BFD_RELOC_NONE, R_unusedb },
1014 { BFD_RELOC_NONE, R_unusedc },
1015 { BFD_RELOC_BFIN_24_PCREL_CALL_X, R_pcrel24_call_x },
1016 { BFD_RELOC_8, R_byte_data },
1017 { BFD_RELOC_16, R_byte2_data },
1018 { BFD_RELOC_32, R_byte4_data },
1019 { BFD_RELOC_BFIN_11_PCREL, R_pcrel11 },
1020 { BFD_RELOC_BFIN_GOT, R_got },
1021 { BFD_RELOC_BFIN_PLTPC, R_pltpc },
1022
1023 { BFD_RELOC_BFIN_GOT17M4, R_BFIN_GOT17M4 },
1024 { BFD_RELOC_BFIN_GOTHI, R_BFIN_GOTHI },
1025 { BFD_RELOC_BFIN_GOTLO, R_BFIN_GOTLO },
1026 { BFD_RELOC_BFIN_FUNCDESC, R_BFIN_FUNCDESC },
1027 { BFD_RELOC_BFIN_FUNCDESC_GOT17M4, R_BFIN_FUNCDESC_GOT17M4 },
1028 { BFD_RELOC_BFIN_FUNCDESC_GOTHI, R_BFIN_FUNCDESC_GOTHI },
1029 { BFD_RELOC_BFIN_FUNCDESC_GOTLO, R_BFIN_FUNCDESC_GOTLO },
1030 { BFD_RELOC_BFIN_FUNCDESC_VALUE, R_BFIN_FUNCDESC_VALUE },
1031 { BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4, R_BFIN_FUNCDESC_GOTOFF17M4 },
1032 { BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI, R_BFIN_FUNCDESC_GOTOFFHI },
1033 { BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO, R_BFIN_FUNCDESC_GOTOFFLO },
1034 { BFD_RELOC_BFIN_GOTOFF17M4, R_BFIN_GOTOFF17M4 },
1035 { BFD_RELOC_BFIN_GOTOFFHI, R_BFIN_GOTOFFHI },
1036 { BFD_RELOC_BFIN_GOTOFFLO, R_BFIN_GOTOFFLO },
1037
1038 { BFD_RELOC_VTABLE_INHERIT, R_BFIN_GNU_VTINHERIT },
1039 { BFD_RELOC_VTABLE_ENTRY, R_BFIN_GNU_VTENTRY },
1040 };
1041
1042
1043 static void
1044 bfin_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
1045 arelent *cache_ptr,
1046 Elf_Internal_Rela *dst)
1047 {
1048 unsigned int r_type;
1049
1050 r_type = ELF32_R_TYPE (dst->r_info);
1051
1052 if (r_type <= BFIN_RELOC_MAX)
1053 cache_ptr->howto = &bfin_howto_table [r_type];
1054
1055 else if (r_type >= BFIN_GNUEXT_RELOC_MIN && r_type <= BFIN_GNUEXT_RELOC_MAX)
1056 cache_ptr->howto = &bfin_gnuext_howto_table [r_type - BFIN_GNUEXT_RELOC_MIN];
1057
1058 else
1059 cache_ptr->howto = (reloc_howto_type *) NULL;
1060 }
1061
1062 /* Given a BFD reloc type, return the howto. */
1063 static reloc_howto_type *
1064 bfin_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
1065 bfd_reloc_code_real_type code)
1066 {
1067 unsigned int i;
1068 unsigned int r_type = BFIN_RELOC_MIN;
1069
1070 for (i = sizeof (bfin_reloc_map) / sizeof (bfin_reloc_map[0]); --i;)
1071 if (bfin_reloc_map[i].bfd_reloc_val == code)
1072 r_type = bfin_reloc_map[i].bfin_reloc_val;
1073
1074 if (r_type <= BFIN_RELOC_MAX && r_type > BFIN_RELOC_MIN)
1075 return &bfin_howto_table [r_type];
1076
1077 else if (r_type >= BFIN_GNUEXT_RELOC_MIN && r_type <= BFIN_GNUEXT_RELOC_MAX)
1078 return &bfin_gnuext_howto_table [r_type - BFIN_GNUEXT_RELOC_MIN];
1079
1080 return (reloc_howto_type *) NULL;
1081 }
1082
1083 static reloc_howto_type *
1084 bfin_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1085 const char *r_name)
1086 {
1087 unsigned int i;
1088
1089 for (i = 0;
1090 i < (sizeof (bfin_howto_table)
1091 / sizeof (bfin_howto_table[0]));
1092 i++)
1093 if (bfin_howto_table[i].name != NULL
1094 && strcasecmp (bfin_howto_table[i].name, r_name) == 0)
1095 return &bfin_howto_table[i];
1096
1097 for (i = 0;
1098 i < (sizeof (bfin_gnuext_howto_table)
1099 / sizeof (bfin_gnuext_howto_table[0]));
1100 i++)
1101 if (bfin_gnuext_howto_table[i].name != NULL
1102 && strcasecmp (bfin_gnuext_howto_table[i].name, r_name) == 0)
1103 return &bfin_gnuext_howto_table[i];
1104
1105 return NULL;
1106 }
1107
1108 /* Given a bfin relocation type, return the howto. */
1109 static reloc_howto_type *
1110 bfin_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
1111 unsigned int r_type)
1112 {
1113 if (r_type <= BFIN_RELOC_MAX)
1114 return &bfin_howto_table [r_type];
1115
1116 else if (r_type >= BFIN_GNUEXT_RELOC_MIN && r_type <= BFIN_GNUEXT_RELOC_MAX)
1117 return &bfin_gnuext_howto_table [r_type - BFIN_GNUEXT_RELOC_MIN];
1118
1119 return (reloc_howto_type *) NULL;
1120 }
1121
1122 /* Return TRUE if the name is a local label.
1123 bfin local labels begin with L$. */
1124 static bfd_boolean
1125 bfin_is_local_label_name (
1126 bfd *abfd ATTRIBUTE_UNUSED,
1127 const char *label)
1128 {
1129 if (label[0] == 'L' && label[1] == '$' )
1130 return TRUE;
1131
1132 return _bfd_elf_is_local_label_name (abfd, label);
1133 }
1134
1135 extern const bfd_target bfd_elf32_bfinfdpic_vec;
1136 #define IS_FDPIC(bfd) ((bfd)->xvec == &bfd_elf32_bfinfdpic_vec)
1137
1138 /* An extension of the elf hash table data structure, containing some
1139 additional Blackfin-specific data. */
1140 struct bfinfdpic_elf_link_hash_table
1141 {
1142 struct elf_link_hash_table elf;
1143
1144 /* A pointer to the .got section. */
1145 asection *sgot;
1146 /* A pointer to the .rel.got section. */
1147 asection *sgotrel;
1148 /* A pointer to the .rofixup section. */
1149 asection *sgotfixup;
1150 /* A pointer to the .plt section. */
1151 asection *splt;
1152 /* A pointer to the .rel.plt section. */
1153 asection *spltrel;
1154 /* GOT base offset. */
1155 bfd_vma got0;
1156 /* Location of the first non-lazy PLT entry, i.e., the number of
1157 bytes taken by lazy PLT entries. */
1158 bfd_vma plt0;
1159 /* A hash table holding information about which symbols were
1160 referenced with which PIC-related relocations. */
1161 struct htab *relocs_info;
1162 };
1163
1164 /* Get the Blackfin ELF linker hash table from a link_info structure. */
1165
1166 #define bfinfdpic_hash_table(info) \
1167 ((struct bfinfdpic_elf_link_hash_table *) ((info)->hash))
1168
1169 #define bfinfdpic_got_section(info) \
1170 (bfinfdpic_hash_table (info)->sgot)
1171 #define bfinfdpic_gotrel_section(info) \
1172 (bfinfdpic_hash_table (info)->sgotrel)
1173 #define bfinfdpic_gotfixup_section(info) \
1174 (bfinfdpic_hash_table (info)->sgotfixup)
1175 #define bfinfdpic_plt_section(info) \
1176 (bfinfdpic_hash_table (info)->splt)
1177 #define bfinfdpic_pltrel_section(info) \
1178 (bfinfdpic_hash_table (info)->spltrel)
1179 #define bfinfdpic_relocs_info(info) \
1180 (bfinfdpic_hash_table (info)->relocs_info)
1181 #define bfinfdpic_got_initial_offset(info) \
1182 (bfinfdpic_hash_table (info)->got0)
1183 #define bfinfdpic_plt_initial_offset(info) \
1184 (bfinfdpic_hash_table (info)->plt0)
1185
1186 /* Create a Blackfin ELF linker hash table. */
1187
1188 static struct bfd_link_hash_table *
1189 bfinfdpic_elf_link_hash_table_create (bfd *abfd)
1190 {
1191 struct bfinfdpic_elf_link_hash_table *ret;
1192 bfd_size_type amt = sizeof (struct bfinfdpic_elf_link_hash_table);
1193
1194 ret = bfd_zalloc (abfd, amt);
1195 if (ret == NULL)
1196 return NULL;
1197
1198 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1199 _bfd_elf_link_hash_newfunc,
1200 sizeof (struct elf_link_hash_entry)))
1201 {
1202 free (ret);
1203 return NULL;
1204 }
1205
1206 return &ret->elf.root;
1207 }
1208
1209 /* Decide whether a reference to a symbol can be resolved locally or
1210 not. If the symbol is protected, we want the local address, but
1211 its function descriptor must be assigned by the dynamic linker. */
1212 #define BFINFDPIC_SYM_LOCAL(INFO, H) \
1213 (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \
1214 || ! elf_hash_table (INFO)->dynamic_sections_created)
1215 #define BFINFDPIC_FUNCDESC_LOCAL(INFO, H) \
1216 ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created)
1217
1218 /* This structure collects information on what kind of GOT, PLT or
1219 function descriptors are required by relocations that reference a
1220 certain symbol. */
1221 struct bfinfdpic_relocs_info
1222 {
1223 /* The index of the symbol, as stored in the relocation r_info, if
1224 we have a local symbol; -1 otherwise. */
1225 long symndx;
1226 union
1227 {
1228 /* The input bfd in which the symbol is defined, if it's a local
1229 symbol. */
1230 bfd *abfd;
1231 /* If symndx == -1, the hash table entry corresponding to a global
1232 symbol (even if it turns out to bind locally, in which case it
1233 should ideally be replaced with section's symndx + addend). */
1234 struct elf_link_hash_entry *h;
1235 } d;
1236 /* The addend of the relocation that references the symbol. */
1237 bfd_vma addend;
1238
1239 /* The fields above are used to identify an entry. The fields below
1240 contain information on how an entry is used and, later on, which
1241 locations it was assigned. */
1242 /* The following 2 fields record whether the symbol+addend above was
1243 ever referenced with a GOT relocation. The 17M4 suffix indicates a
1244 GOT17M4 relocation; hilo is used for GOTLO/GOTHI pairs. */
1245 unsigned got17m4:1;
1246 unsigned gothilo:1;
1247 /* Whether a FUNCDESC relocation references symbol+addend. */
1248 unsigned fd:1;
1249 /* Whether a FUNCDESC_GOT relocation references symbol+addend. */
1250 unsigned fdgot17m4:1;
1251 unsigned fdgothilo:1;
1252 /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend. */
1253 unsigned fdgoff17m4:1;
1254 unsigned fdgoffhilo:1;
1255 /* Whether symbol+addend is referenced with GOTOFF17M4, GOTOFFLO or
1256 GOTOFFHI relocations. The addend doesn't really matter, since we
1257 envision that this will only be used to check whether the symbol
1258 is mapped to the same segment as the got. */
1259 unsigned gotoff:1;
1260 /* Whether symbol+addend is referenced by a LABEL24 relocation. */
1261 unsigned call:1;
1262 /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE
1263 relocation. */
1264 unsigned sym:1;
1265 /* Whether we need a PLT entry for a symbol. Should be implied by
1266 something like:
1267 (call && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h)) */
1268 unsigned plt:1;
1269 /* Whether a function descriptor should be created in this link unit
1270 for symbol+addend. Should be implied by something like:
1271 (plt || fdgotoff17m4 || fdgotofflohi
1272 || ((fd || fdgot17m4 || fdgothilo)
1273 && (symndx != -1 || BFINFDPIC_FUNCDESC_LOCAL (info, d.h)))) */
1274 unsigned privfd:1;
1275 /* Whether a lazy PLT entry is needed for this symbol+addend.
1276 Should be implied by something like:
1277 (privfd && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h)
1278 && ! (info->flags & DF_BIND_NOW)) */
1279 unsigned lazyplt:1;
1280 /* Whether we've already emitted GOT relocations and PLT entries as
1281 needed for this symbol. */
1282 unsigned done:1;
1283
1284 /* The number of R_byte4_data, R_BFIN_FUNCDESC and R_BFIN_FUNCDESC_VALUE
1285 relocations referencing the symbol. */
1286 unsigned relocs32, relocsfd, relocsfdv;
1287
1288 /* The number of .rofixups entries and dynamic relocations allocated
1289 for this symbol, minus any that might have already been used. */
1290 unsigned fixups, dynrelocs;
1291
1292 /* The offsets of the GOT entries assigned to symbol+addend, to the
1293 function descriptor's address, and to a function descriptor,
1294 respectively. Should be zero if unassigned. The offsets are
1295 counted from the value that will be assigned to the PIC register,
1296 not from the beginning of the .got section. */
1297 bfd_signed_vma got_entry, fdgot_entry, fd_entry;
1298 /* The offsets of the PLT entries assigned to symbol+addend,
1299 non-lazy and lazy, respectively. If unassigned, should be
1300 (bfd_vma)-1. */
1301 bfd_vma plt_entry, lzplt_entry;
1302 };
1303
1304 /* Compute a hash with the key fields of an bfinfdpic_relocs_info entry. */
1305 static hashval_t
1306 bfinfdpic_relocs_info_hash (const void *entry_)
1307 {
1308 const struct bfinfdpic_relocs_info *entry = entry_;
1309
1310 return (entry->symndx == -1
1311 ? (long) entry->d.h->root.root.hash
1312 : entry->symndx + (long) entry->d.abfd->id * 257) + entry->addend;
1313 }
1314
1315 /* Test whether the key fields of two bfinfdpic_relocs_info entries are
1316 identical. */
1317 static int
1318 bfinfdpic_relocs_info_eq (const void *entry1, const void *entry2)
1319 {
1320 const struct bfinfdpic_relocs_info *e1 = entry1;
1321 const struct bfinfdpic_relocs_info *e2 = entry2;
1322
1323 return e1->symndx == e2->symndx && e1->addend == e2->addend
1324 && (e1->symndx == -1 ? e1->d.h == e2->d.h : e1->d.abfd == e2->d.abfd);
1325 }
1326
1327 /* Find or create an entry in a hash table HT that matches the key
1328 fields of the given ENTRY. If it's not found, memory for a new
1329 entry is allocated in ABFD's obstack. */
1330 static struct bfinfdpic_relocs_info *
1331 bfinfdpic_relocs_info_find (struct htab *ht,
1332 bfd *abfd,
1333 const struct bfinfdpic_relocs_info *entry,
1334 enum insert_option insert)
1335 {
1336 struct bfinfdpic_relocs_info **loc =
1337 (struct bfinfdpic_relocs_info **) htab_find_slot (ht, entry, insert);
1338
1339 if (! loc)
1340 return NULL;
1341
1342 if (*loc)
1343 return *loc;
1344
1345 *loc = bfd_zalloc (abfd, sizeof (**loc));
1346
1347 if (! *loc)
1348 return *loc;
1349
1350 (*loc)->symndx = entry->symndx;
1351 (*loc)->d = entry->d;
1352 (*loc)->addend = entry->addend;
1353 (*loc)->plt_entry = (bfd_vma)-1;
1354 (*loc)->lzplt_entry = (bfd_vma)-1;
1355
1356 return *loc;
1357 }
1358
1359 /* Obtain the address of the entry in HT associated with H's symbol +
1360 addend, creating a new entry if none existed. ABFD is only used
1361 for memory allocation purposes. */
1362 inline static struct bfinfdpic_relocs_info *
1363 bfinfdpic_relocs_info_for_global (struct htab *ht,
1364 bfd *abfd,
1365 struct elf_link_hash_entry *h,
1366 bfd_vma addend,
1367 enum insert_option insert)
1368 {
1369 struct bfinfdpic_relocs_info entry;
1370
1371 entry.symndx = -1;
1372 entry.d.h = h;
1373 entry.addend = addend;
1374
1375 return bfinfdpic_relocs_info_find (ht, abfd, &entry, insert);
1376 }
1377
1378 /* Obtain the address of the entry in HT associated with the SYMNDXth
1379 local symbol of the input bfd ABFD, plus the addend, creating a new
1380 entry if none existed. */
1381 inline static struct bfinfdpic_relocs_info *
1382 bfinfdpic_relocs_info_for_local (struct htab *ht,
1383 bfd *abfd,
1384 long symndx,
1385 bfd_vma addend,
1386 enum insert_option insert)
1387 {
1388 struct bfinfdpic_relocs_info entry;
1389
1390 entry.symndx = symndx;
1391 entry.d.abfd = abfd;
1392 entry.addend = addend;
1393
1394 return bfinfdpic_relocs_info_find (ht, abfd, &entry, insert);
1395 }
1396
1397 /* Merge fields set by check_relocs() of two entries that end up being
1398 mapped to the same (presumably global) symbol. */
1399
1400 inline static void
1401 bfinfdpic_pic_merge_early_relocs_info (struct bfinfdpic_relocs_info *e2,
1402 struct bfinfdpic_relocs_info const *e1)
1403 {
1404 e2->got17m4 |= e1->got17m4;
1405 e2->gothilo |= e1->gothilo;
1406 e2->fd |= e1->fd;
1407 e2->fdgot17m4 |= e1->fdgot17m4;
1408 e2->fdgothilo |= e1->fdgothilo;
1409 e2->fdgoff17m4 |= e1->fdgoff17m4;
1410 e2->fdgoffhilo |= e1->fdgoffhilo;
1411 e2->gotoff |= e1->gotoff;
1412 e2->call |= e1->call;
1413 e2->sym |= e1->sym;
1414 }
1415
1416 /* Every block of 65535 lazy PLT entries shares a single call to the
1417 resolver, inserted in the 32768th lazy PLT entry (i.e., entry #
1418 32767, counting from 0). All other lazy PLT entries branch to it
1419 in a single instruction. */
1420
1421 #define LZPLT_RESOLVER_EXTRA 10
1422 #define LZPLT_NORMAL_SIZE 6
1423 #define LZPLT_ENTRIES 1362
1424
1425 #define BFINFDPIC_LZPLT_BLOCK_SIZE ((bfd_vma) LZPLT_NORMAL_SIZE * LZPLT_ENTRIES + LZPLT_RESOLVER_EXTRA)
1426 #define BFINFDPIC_LZPLT_RESOLV_LOC (LZPLT_NORMAL_SIZE * LZPLT_ENTRIES / 2)
1427
1428 /* Add a dynamic relocation to the SRELOC section. */
1429
1430 inline static bfd_vma
1431 _bfinfdpic_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset,
1432 int reloc_type, long dynindx, bfd_vma addend,
1433 struct bfinfdpic_relocs_info *entry)
1434 {
1435 Elf_Internal_Rela outrel;
1436 bfd_vma reloc_offset;
1437
1438 outrel.r_offset = offset;
1439 outrel.r_info = ELF32_R_INFO (dynindx, reloc_type);
1440 outrel.r_addend = addend;
1441
1442 reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rel);
1443 BFD_ASSERT (reloc_offset < sreloc->size);
1444 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1445 sreloc->contents + reloc_offset);
1446 sreloc->reloc_count++;
1447
1448 /* If the entry's index is zero, this relocation was probably to a
1449 linkonce section that got discarded. We reserved a dynamic
1450 relocation, but it was for another entry than the one we got at
1451 the time of emitting the relocation. Unfortunately there's no
1452 simple way for us to catch this situation, since the relocation
1453 is cleared right before calling relocate_section, at which point
1454 we no longer know what the relocation used to point to. */
1455 if (entry->symndx)
1456 {
1457 BFD_ASSERT (entry->dynrelocs > 0);
1458 entry->dynrelocs--;
1459 }
1460
1461 return reloc_offset;
1462 }
1463
1464 /* Add a fixup to the ROFIXUP section. */
1465
1466 static bfd_vma
1467 _bfinfdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma offset,
1468 struct bfinfdpic_relocs_info *entry)
1469 {
1470 bfd_vma fixup_offset;
1471
1472 if (rofixup->flags & SEC_EXCLUDE)
1473 return -1;
1474
1475 fixup_offset = rofixup->reloc_count * 4;
1476 if (rofixup->contents)
1477 {
1478 BFD_ASSERT (fixup_offset < rofixup->size);
1479 bfd_put_32 (output_bfd, offset, rofixup->contents + fixup_offset);
1480 }
1481 rofixup->reloc_count++;
1482
1483 if (entry && entry->symndx)
1484 {
1485 /* See discussion about symndx == 0 in _bfinfdpic_add_dyn_reloc
1486 above. */
1487 BFD_ASSERT (entry->fixups > 0);
1488 entry->fixups--;
1489 }
1490
1491 return fixup_offset;
1492 }
1493
1494 /* Find the segment number in which OSEC, and output section, is
1495 located. */
1496
1497 static unsigned
1498 _bfinfdpic_osec_to_segment (bfd *output_bfd, asection *osec)
1499 {
1500 struct elf_segment_map *m;
1501 Elf_Internal_Phdr *p;
1502
1503 /* Find the segment that contains the output_section. */
1504 for (m = elf_tdata (output_bfd)->segment_map,
1505 p = elf_tdata (output_bfd)->phdr;
1506 m != NULL;
1507 m = m->next, p++)
1508 {
1509 int i;
1510
1511 for (i = m->count - 1; i >= 0; i--)
1512 if (m->sections[i] == osec)
1513 break;
1514
1515 if (i >= 0)
1516 break;
1517 }
1518
1519 return p - elf_tdata (output_bfd)->phdr;
1520 }
1521
1522 inline static bfd_boolean
1523 _bfinfdpic_osec_readonly_p (bfd *output_bfd, asection *osec)
1524 {
1525 unsigned seg = _bfinfdpic_osec_to_segment (output_bfd, osec);
1526
1527 return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
1528 }
1529
1530 /* Generate relocations for GOT entries, function descriptors, and
1531 code for PLT and lazy PLT entries. */
1532
1533 inline static bfd_boolean
1534 _bfinfdpic_emit_got_relocs_plt_entries (struct bfinfdpic_relocs_info *entry,
1535 bfd *output_bfd,
1536 struct bfd_link_info *info,
1537 asection *sec,
1538 Elf_Internal_Sym *sym,
1539 bfd_vma addend)
1540
1541 {
1542 bfd_vma fd_lazy_rel_offset = (bfd_vma)-1;
1543 int dynindx = -1;
1544
1545 if (entry->done)
1546 return TRUE;
1547 entry->done = 1;
1548
1549 if (entry->got_entry || entry->fdgot_entry || entry->fd_entry)
1550 {
1551 /* If the symbol is dynamic, consider it for dynamic
1552 relocations, otherwise decay to section + offset. */
1553 if (entry->symndx == -1 && entry->d.h->dynindx != -1)
1554 dynindx = entry->d.h->dynindx;
1555 else
1556 {
1557 if (sec->output_section
1558 && ! bfd_is_abs_section (sec->output_section)
1559 && ! bfd_is_und_section (sec->output_section))
1560 dynindx = elf_section_data (sec->output_section)->dynindx;
1561 else
1562 dynindx = 0;
1563 }
1564 }
1565
1566 /* Generate relocation for GOT entry pointing to the symbol. */
1567 if (entry->got_entry)
1568 {
1569 int idx = dynindx;
1570 bfd_vma ad = addend;
1571
1572 /* If the symbol is dynamic but binds locally, use
1573 section+offset. */
1574 if (sec && (entry->symndx != -1
1575 || BFINFDPIC_SYM_LOCAL (info, entry->d.h)))
1576 {
1577 if (entry->symndx == -1)
1578 ad += entry->d.h->root.u.def.value;
1579 else
1580 ad += sym->st_value;
1581 ad += sec->output_offset;
1582 if (sec->output_section && elf_section_data (sec->output_section))
1583 idx = elf_section_data (sec->output_section)->dynindx;
1584 else
1585 idx = 0;
1586 }
1587
1588 /* If we're linking an executable at a fixed address, we can
1589 omit the dynamic relocation as long as the symbol is local to
1590 this module. */
1591 if (info->executable && !info->pie
1592 && (entry->symndx != -1
1593 || BFINFDPIC_SYM_LOCAL (info, entry->d.h)))
1594 {
1595 if (sec)
1596 ad += sec->output_section->vma;
1597 if (entry->symndx != -1
1598 || entry->d.h->root.type != bfd_link_hash_undefweak)
1599 _bfinfdpic_add_rofixup (output_bfd,
1600 bfinfdpic_gotfixup_section (info),
1601 bfinfdpic_got_section (info)->output_section
1602 ->vma
1603 + bfinfdpic_got_section (info)->output_offset
1604 + bfinfdpic_got_initial_offset (info)
1605 + entry->got_entry, entry);
1606 }
1607 else
1608 _bfinfdpic_add_dyn_reloc (output_bfd, bfinfdpic_gotrel_section (info),
1609 _bfd_elf_section_offset
1610 (output_bfd, info,
1611 bfinfdpic_got_section (info),
1612 bfinfdpic_got_initial_offset (info)
1613 + entry->got_entry)
1614 + bfinfdpic_got_section (info)
1615 ->output_section->vma
1616 + bfinfdpic_got_section (info)->output_offset,
1617 R_byte4_data, idx, ad, entry);
1618
1619 bfd_put_32 (output_bfd, ad,
1620 bfinfdpic_got_section (info)->contents
1621 + bfinfdpic_got_initial_offset (info)
1622 + entry->got_entry);
1623 }
1624
1625 /* Generate relocation for GOT entry pointing to a canonical
1626 function descriptor. */
1627 if (entry->fdgot_entry)
1628 {
1629 int reloc, idx;
1630 bfd_vma ad = 0;
1631
1632 if (! (entry->symndx == -1
1633 && entry->d.h->root.type == bfd_link_hash_undefweak
1634 && BFINFDPIC_SYM_LOCAL (info, entry->d.h)))
1635 {
1636 /* If the symbol is dynamic and there may be dynamic symbol
1637 resolution because we are, or are linked with, a shared
1638 library, emit a FUNCDESC relocation such that the dynamic
1639 linker will allocate the function descriptor. If the
1640 symbol needs a non-local function descriptor but binds
1641 locally (e.g., its visibility is protected, emit a
1642 dynamic relocation decayed to section+offset. */
1643 if (entry->symndx == -1
1644 && ! BFINFDPIC_FUNCDESC_LOCAL (info, entry->d.h)
1645 && BFINFDPIC_SYM_LOCAL (info, entry->d.h)
1646 && !(info->executable && !info->pie))
1647 {
1648 reloc = R_BFIN_FUNCDESC;
1649 idx = elf_section_data (entry->d.h->root.u.def.section
1650 ->output_section)->dynindx;
1651 ad = entry->d.h->root.u.def.section->output_offset
1652 + entry->d.h->root.u.def.value;
1653 }
1654 else if (entry->symndx == -1
1655 && ! BFINFDPIC_FUNCDESC_LOCAL (info, entry->d.h))
1656 {
1657 reloc = R_BFIN_FUNCDESC;
1658 idx = dynindx;
1659 ad = addend;
1660 if (ad)
1661 return FALSE;
1662 }
1663 else
1664 {
1665 /* Otherwise, we know we have a private function descriptor,
1666 so reference it directly. */
1667 if (elf_hash_table (info)->dynamic_sections_created)
1668 BFD_ASSERT (entry->privfd);
1669 reloc = R_byte4_data;
1670 idx = elf_section_data (bfinfdpic_got_section (info)
1671 ->output_section)->dynindx;
1672 ad = bfinfdpic_got_section (info)->output_offset
1673 + bfinfdpic_got_initial_offset (info) + entry->fd_entry;
1674 }
1675
1676 /* If there is room for dynamic symbol resolution, emit the
1677 dynamic relocation. However, if we're linking an
1678 executable at a fixed location, we won't have emitted a
1679 dynamic symbol entry for the got section, so idx will be
1680 zero, which means we can and should compute the address
1681 of the private descriptor ourselves. */
1682 if (info->executable && !info->pie
1683 && (entry->symndx != -1
1684 || BFINFDPIC_FUNCDESC_LOCAL (info, entry->d.h)))
1685 {
1686 ad += bfinfdpic_got_section (info)->output_section->vma;
1687 _bfinfdpic_add_rofixup (output_bfd,
1688 bfinfdpic_gotfixup_section (info),
1689 bfinfdpic_got_section (info)
1690 ->output_section->vma
1691 + bfinfdpic_got_section (info)
1692 ->output_offset
1693 + bfinfdpic_got_initial_offset (info)
1694 + entry->fdgot_entry, entry);
1695 }
1696 else
1697 _bfinfdpic_add_dyn_reloc (output_bfd,
1698 bfinfdpic_gotrel_section (info),
1699 _bfd_elf_section_offset
1700 (output_bfd, info,
1701 bfinfdpic_got_section (info),
1702 bfinfdpic_got_initial_offset (info)
1703 + entry->fdgot_entry)
1704 + bfinfdpic_got_section (info)
1705 ->output_section->vma
1706 + bfinfdpic_got_section (info)
1707 ->output_offset,
1708 reloc, idx, ad, entry);
1709 }
1710
1711 bfd_put_32 (output_bfd, ad,
1712 bfinfdpic_got_section (info)->contents
1713 + bfinfdpic_got_initial_offset (info)
1714 + entry->fdgot_entry);
1715 }
1716
1717 /* Generate relocation to fill in a private function descriptor in
1718 the GOT. */
1719 if (entry->fd_entry)
1720 {
1721 int idx = dynindx;
1722 bfd_vma ad = addend;
1723 bfd_vma ofst;
1724 long lowword, highword;
1725
1726 /* If the symbol is dynamic but binds locally, use
1727 section+offset. */
1728 if (sec && (entry->symndx != -1
1729 || BFINFDPIC_SYM_LOCAL (info, entry->d.h)))
1730 {
1731 if (entry->symndx == -1)
1732 ad += entry->d.h->root.u.def.value;
1733 else
1734 ad += sym->st_value;
1735 ad += sec->output_offset;
1736 if (sec->output_section && elf_section_data (sec->output_section))
1737 idx = elf_section_data (sec->output_section)->dynindx;
1738 else
1739 idx = 0;
1740 }
1741
1742 /* If we're linking an executable at a fixed address, we can
1743 omit the dynamic relocation as long as the symbol is local to
1744 this module. */
1745 if (info->executable && !info->pie
1746 && (entry->symndx != -1 || BFINFDPIC_SYM_LOCAL (info, entry->d.h)))
1747 {
1748 if (sec)
1749 ad += sec->output_section->vma;
1750 ofst = 0;
1751 if (entry->symndx != -1
1752 || entry->d.h->root.type != bfd_link_hash_undefweak)
1753 {
1754 _bfinfdpic_add_rofixup (output_bfd,
1755 bfinfdpic_gotfixup_section (info),
1756 bfinfdpic_got_section (info)
1757 ->output_section->vma
1758 + bfinfdpic_got_section (info)
1759 ->output_offset
1760 + bfinfdpic_got_initial_offset (info)
1761 + entry->fd_entry, entry);
1762 _bfinfdpic_add_rofixup (output_bfd,
1763 bfinfdpic_gotfixup_section (info),
1764 bfinfdpic_got_section (info)
1765 ->output_section->vma
1766 + bfinfdpic_got_section (info)
1767 ->output_offset
1768 + bfinfdpic_got_initial_offset (info)
1769 + entry->fd_entry + 4, entry);
1770 }
1771 }
1772 else
1773 {
1774 ofst
1775 = _bfinfdpic_add_dyn_reloc (output_bfd,
1776 entry->lazyplt
1777 ? bfinfdpic_pltrel_section (info)
1778 : bfinfdpic_gotrel_section (info),
1779 _bfd_elf_section_offset
1780 (output_bfd, info,
1781 bfinfdpic_got_section (info),
1782 bfinfdpic_got_initial_offset (info)
1783 + entry->fd_entry)
1784 + bfinfdpic_got_section (info)
1785 ->output_section->vma
1786 + bfinfdpic_got_section (info)
1787 ->output_offset,
1788 R_BFIN_FUNCDESC_VALUE, idx, ad, entry);
1789 }
1790
1791 /* If we've omitted the dynamic relocation, just emit the fixed
1792 addresses of the symbol and of the local GOT base offset. */
1793 if (info->executable && !info->pie && sec && sec->output_section)
1794 {
1795 lowword = ad;
1796 highword = bfinfdpic_got_section (info)->output_section->vma
1797 + bfinfdpic_got_section (info)->output_offset
1798 + bfinfdpic_got_initial_offset (info);
1799 }
1800 else if (entry->lazyplt)
1801 {
1802 if (ad)
1803 return FALSE;
1804
1805 fd_lazy_rel_offset = ofst;
1806
1807 /* A function descriptor used for lazy or local resolving is
1808 initialized such that its high word contains the output
1809 section index in which the PLT entries are located, and
1810 the low word contains the address of the lazy PLT entry
1811 entry point, that must be within the memory region
1812 assigned to that section. */
1813 lowword = entry->lzplt_entry + 4
1814 + bfinfdpic_plt_section (info)->output_offset
1815 + bfinfdpic_plt_section (info)->output_section->vma;
1816 highword = _bfinfdpic_osec_to_segment
1817 (output_bfd, bfinfdpic_plt_section (info)->output_section);
1818 }
1819 else
1820 {
1821 /* A function descriptor for a local function gets the index
1822 of the section. For a non-local function, it's
1823 disregarded. */
1824 lowword = ad;
1825 if (entry->symndx == -1 && entry->d.h->dynindx != -1
1826 && entry->d.h->dynindx == idx)
1827 highword = 0;
1828 else
1829 highword = _bfinfdpic_osec_to_segment
1830 (output_bfd, sec->output_section);
1831 }
1832
1833 bfd_put_32 (output_bfd, lowword,
1834 bfinfdpic_got_section (info)->contents
1835 + bfinfdpic_got_initial_offset (info)
1836 + entry->fd_entry);
1837 bfd_put_32 (output_bfd, highword,
1838 bfinfdpic_got_section (info)->contents
1839 + bfinfdpic_got_initial_offset (info)
1840 + entry->fd_entry + 4);
1841 }
1842
1843 /* Generate code for the PLT entry. */
1844 if (entry->plt_entry != (bfd_vma) -1)
1845 {
1846 bfd_byte *plt_code = bfinfdpic_plt_section (info)->contents
1847 + entry->plt_entry;
1848
1849 BFD_ASSERT (entry->fd_entry);
1850
1851 /* Figure out what kind of PLT entry we need, depending on the
1852 location of the function descriptor within the GOT. */
1853 if (entry->fd_entry >= -(1 << (18 - 1))
1854 && entry->fd_entry + 4 < (1 << (18 - 1)))
1855 {
1856 /* P1 = [P3 + fd_entry]; P3 = [P3 + fd_entry + 4] */
1857 bfd_put_32 (output_bfd,
1858 0xe519 | ((entry->fd_entry << 14) & 0xFFFF0000),
1859 plt_code);
1860 bfd_put_32 (output_bfd,
1861 0xe51b | (((entry->fd_entry + 4) << 14) & 0xFFFF0000),
1862 plt_code + 4);
1863 plt_code += 8;
1864 }
1865 else
1866 {
1867 /* P1.L = fd_entry; P1.H = fd_entry;
1868 P3 = P3 + P1;
1869 P1 = [P3];
1870 P3 = [P3 + 4]; */
1871 bfd_put_32 (output_bfd,
1872 0xe109 | (entry->fd_entry << 16),
1873 plt_code);
1874 bfd_put_32 (output_bfd,
1875 0xe149 | (entry->fd_entry & 0xFFFF0000),
1876 plt_code + 4);
1877 bfd_put_16 (output_bfd, 0x5ad9, plt_code + 8);
1878 bfd_put_16 (output_bfd, 0x9159, plt_code + 10);
1879 bfd_put_16 (output_bfd, 0xac5b, plt_code + 12);
1880 plt_code += 14;
1881 }
1882 /* JUMP (P1) */
1883 bfd_put_16 (output_bfd, 0x0051, plt_code);
1884 }
1885
1886 /* Generate code for the lazy PLT entry. */
1887 if (entry->lzplt_entry != (bfd_vma) -1)
1888 {
1889 bfd_byte *lzplt_code = bfinfdpic_plt_section (info)->contents
1890 + entry->lzplt_entry;
1891 bfd_vma resolverStub_addr;
1892
1893 bfd_put_32 (output_bfd, fd_lazy_rel_offset, lzplt_code);
1894 lzplt_code += 4;
1895
1896 resolverStub_addr = entry->lzplt_entry / BFINFDPIC_LZPLT_BLOCK_SIZE
1897 * BFINFDPIC_LZPLT_BLOCK_SIZE + BFINFDPIC_LZPLT_RESOLV_LOC;
1898 if (resolverStub_addr >= bfinfdpic_plt_initial_offset (info))
1899 resolverStub_addr = bfinfdpic_plt_initial_offset (info) - LZPLT_NORMAL_SIZE - LZPLT_RESOLVER_EXTRA;
1900
1901 if (entry->lzplt_entry == resolverStub_addr)
1902 {
1903 /* This is a lazy PLT entry that includes a resolver call.
1904 P2 = [P3];
1905 R3 = [P3 + 4];
1906 JUMP (P2); */
1907 bfd_put_32 (output_bfd,
1908 0xa05b915a,
1909 lzplt_code);
1910 bfd_put_16 (output_bfd, 0x0052, lzplt_code + 4);
1911 }
1912 else
1913 {
1914 /* JUMP.S resolverStub */
1915 bfd_put_16 (output_bfd,
1916 0x2000
1917 | (((resolverStub_addr - entry->lzplt_entry)
1918 / 2) & (((bfd_vma)1 << 12) - 1)),
1919 lzplt_code);
1920 }
1921 }
1922
1923 return TRUE;
1924 }
1925
1926
1927 /* Look through the relocs for a section during the first phase, and
1928 allocate space in the global offset table or procedure linkage
1929 table. */
1930
1931 static bfd_boolean
1932 bfin_check_relocs (bfd * abfd,
1933 struct bfd_link_info *info,
1934 asection *sec,
1935 const Elf_Internal_Rela *relocs)
1936 {
1937 bfd *dynobj;
1938 Elf_Internal_Shdr *symtab_hdr;
1939 struct elf_link_hash_entry **sym_hashes;
1940 bfd_signed_vma *local_got_refcounts;
1941 const Elf_Internal_Rela *rel;
1942 const Elf_Internal_Rela *rel_end;
1943 asection *sgot;
1944 asection *srelgot;
1945 asection *sreloc;
1946 if (info->relocatable)
1947 return TRUE;
1948
1949 dynobj = elf_hash_table (info)->dynobj;
1950 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1951 sym_hashes = elf_sym_hashes (abfd);
1952 local_got_refcounts = elf_local_got_refcounts (abfd);
1953
1954 sgot = NULL;
1955 srelgot = NULL;
1956 sreloc = NULL;
1957
1958 rel_end = relocs + sec->reloc_count;
1959 for (rel = relocs; rel < rel_end; rel++)
1960 {
1961 unsigned long r_symndx;
1962 struct elf_link_hash_entry *h;
1963
1964 r_symndx = ELF32_R_SYM (rel->r_info);
1965 if (r_symndx < symtab_hdr->sh_info)
1966 h = NULL;
1967 else
1968 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1969
1970 switch (ELF32_R_TYPE (rel->r_info))
1971 {
1972 /* This relocation describes the C++ object vtable hierarchy.
1973 Reconstruct it for later use during GC. */
1974 case R_BFIN_GNU_VTINHERIT:
1975 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1976 return FALSE;
1977 break;
1978
1979 /* This relocation describes which C++ vtable entries
1980 are actually used. Record for later use during GC. */
1981 case R_BFIN_GNU_VTENTRY:
1982 BFD_ASSERT (h != NULL);
1983 if (h != NULL
1984 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1985 return FALSE;
1986 break;
1987
1988 case R_got:
1989 if (h != NULL
1990 && strcmp (h->root.root.string, "__GLOBAL_OFFSET_TABLE_") == 0)
1991 break;
1992 /* Fall through. */
1993
1994 if (dynobj == NULL)
1995 {
1996 /* Create the .got section. */
1997 elf_hash_table (info)->dynobj = dynobj = abfd;
1998 if (!_bfd_elf_create_got_section (dynobj, info))
1999 return FALSE;
2000 }
2001
2002 if (sgot == NULL)
2003 {
2004 sgot = bfd_get_section_by_name (dynobj, ".got");
2005 BFD_ASSERT (sgot != NULL);
2006 }
2007
2008 if (srelgot == NULL && (h != NULL || info->shared))
2009 {
2010 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2011 if (srelgot == NULL)
2012 {
2013 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
2014 | SEC_IN_MEMORY | SEC_LINKER_CREATED
2015 | SEC_READONLY);
2016 srelgot = bfd_make_section_with_flags (dynobj, ".rela.got",
2017 flags);
2018 if (srelgot == NULL
2019 || !bfd_set_section_alignment (dynobj, srelgot, 2))
2020 return FALSE;
2021 }
2022 }
2023
2024 if (h != NULL)
2025 {
2026 if (h->got.refcount == 0)
2027 {
2028 /* Make sure this symbol is output as a dynamic symbol. */
2029 if (h->dynindx == -1 && !h->forced_local)
2030 {
2031 if (!bfd_elf_link_record_dynamic_symbol (info, h))
2032 return FALSE;
2033 }
2034
2035 /* Allocate space in the .got section. */
2036 sgot->size += 4;
2037 /* Allocate relocation space. */
2038 srelgot->size += sizeof (Elf32_External_Rela);
2039 }
2040 h->got.refcount++;
2041 }
2042 else
2043 {
2044 /* This is a global offset table entry for a local symbol. */
2045 if (local_got_refcounts == NULL)
2046 {
2047 bfd_size_type size;
2048
2049 size = symtab_hdr->sh_info;
2050 size *= sizeof (bfd_signed_vma);
2051 local_got_refcounts = ((bfd_signed_vma *)
2052 bfd_zalloc (abfd, size));
2053 if (local_got_refcounts == NULL)
2054 return FALSE;
2055 elf_local_got_refcounts (abfd) = local_got_refcounts;
2056 }
2057 if (local_got_refcounts[r_symndx] == 0)
2058 {
2059 sgot->size += 4;
2060 if (info->shared)
2061 {
2062 /* If we are generating a shared object, we need to
2063 output a R_68K_RELATIVE reloc so that the dynamic
2064 linker can adjust this GOT entry. */
2065 srelgot->size += sizeof (Elf32_External_Rela);
2066 }
2067 }
2068 local_got_refcounts[r_symndx]++;
2069 }
2070 break;
2071
2072 default:
2073 break;
2074 }
2075 }
2076
2077 return TRUE;
2078 }
2079
2080 static enum elf_reloc_type_class
2081 elf32_bfin_reloc_type_class (const Elf_Internal_Rela * rela)
2082 {
2083 switch ((int) ELF32_R_TYPE (rela->r_info))
2084 {
2085 default:
2086 return reloc_class_normal;
2087 }
2088 }
2089 \f
2090 /* Relocate an Blackfin ELF section.
2091
2092 The RELOCATE_SECTION function is called by the new ELF backend linker
2093 to handle the relocations for a section.
2094
2095 The relocs are always passed as Rela structures; if the section
2096 actually uses Rel structures, the r_addend field will always be
2097 zero.
2098
2099 This function is responsible for adjusting the section contents as
2100 necessary, and (if using Rela relocs and generating a relocatable
2101 output file) adjusting the reloc addend as necessary.
2102
2103 This function does not have to worry about setting the reloc
2104 address or the reloc symbol index.
2105
2106 LOCAL_SYMS is a pointer to the swapped in local symbols.
2107
2108 LOCAL_SECTIONS is an array giving the section in the input file
2109 corresponding to the st_shndx field of each local symbol.
2110
2111 The global hash table entry for the global symbols can be found
2112 via elf_sym_hashes (input_bfd).
2113
2114 When generating relocatable output, this function must handle
2115 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
2116 going to be the section symbol corresponding to the output
2117 section, which means that the addend must be adjusted
2118 accordingly. */
2119
2120 static bfd_boolean
2121 bfinfdpic_relocate_section (bfd * output_bfd,
2122 struct bfd_link_info *info,
2123 bfd * input_bfd,
2124 asection * input_section,
2125 bfd_byte * contents,
2126 Elf_Internal_Rela * relocs,
2127 Elf_Internal_Sym * local_syms,
2128 asection ** local_sections)
2129 {
2130 Elf_Internal_Shdr *symtab_hdr;
2131 struct elf_link_hash_entry **sym_hashes;
2132 Elf_Internal_Rela *rel;
2133 Elf_Internal_Rela *relend;
2134 unsigned isec_segment, got_segment, plt_segment,
2135 check_segment[2];
2136 int silence_segment_error = !(info->shared || info->pie);
2137
2138 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2139 sym_hashes = elf_sym_hashes (input_bfd);
2140 relend = relocs + input_section->reloc_count;
2141
2142 isec_segment = _bfinfdpic_osec_to_segment (output_bfd,
2143 input_section->output_section);
2144 if (IS_FDPIC (output_bfd) && bfinfdpic_got_section (info))
2145 got_segment = _bfinfdpic_osec_to_segment (output_bfd,
2146 bfinfdpic_got_section (info)
2147 ->output_section);
2148 else
2149 got_segment = -1;
2150 if (IS_FDPIC (output_bfd) && elf_hash_table (info)->dynamic_sections_created)
2151 plt_segment = _bfinfdpic_osec_to_segment (output_bfd,
2152 bfinfdpic_plt_section (info)
2153 ->output_section);
2154 else
2155 plt_segment = -1;
2156
2157 for (rel = relocs; rel < relend; rel ++)
2158 {
2159 reloc_howto_type *howto;
2160 unsigned long r_symndx;
2161 Elf_Internal_Sym *sym;
2162 asection *sec;
2163 struct elf_link_hash_entry *h;
2164 bfd_vma relocation;
2165 bfd_reloc_status_type r;
2166 const char * name = NULL;
2167 int r_type;
2168 asection *osec;
2169 struct bfinfdpic_relocs_info *picrel;
2170 bfd_vma orig_addend = rel->r_addend;
2171
2172 r_type = ELF32_R_TYPE (rel->r_info);
2173
2174 if (r_type == R_BFIN_GNU_VTINHERIT
2175 || r_type == R_BFIN_GNU_VTENTRY)
2176 continue;
2177
2178 r_symndx = ELF32_R_SYM (rel->r_info);
2179 howto = bfin_reloc_type_lookup (input_bfd, r_type);
2180 if (howto == NULL)
2181 {
2182 bfd_set_error (bfd_error_bad_value);
2183 return FALSE;
2184 }
2185
2186 h = NULL;
2187 sym = NULL;
2188 sec = NULL;
2189
2190 if (r_symndx < symtab_hdr->sh_info)
2191 {
2192 sym = local_syms + r_symndx;
2193 osec = sec = local_sections [r_symndx];
2194 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2195
2196 name = bfd_elf_string_from_elf_section
2197 (input_bfd, symtab_hdr->sh_link, sym->st_name);
2198 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
2199 }
2200 else
2201 {
2202 bfd_boolean warned;
2203 bfd_boolean unresolved_reloc;
2204
2205 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2206 r_symndx, symtab_hdr, sym_hashes,
2207 h, sec, relocation,
2208 unresolved_reloc, warned);
2209 osec = sec;
2210 }
2211
2212 if (sec != NULL && elf_discarded_section (sec))
2213 {
2214 /* For relocs against symbols from removed linkonce sections,
2215 or sections discarded by a linker script, we just want the
2216 section contents zeroed. Avoid any special processing. */
2217 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2218 rel->r_info = 0;
2219 rel->r_addend = 0;
2220 continue;
2221 }
2222
2223 if (info->relocatable)
2224 continue;
2225
2226 if (h != NULL
2227 && (h->root.type == bfd_link_hash_defined
2228 || h->root.type == bfd_link_hash_defweak)
2229 && !BFINFDPIC_SYM_LOCAL (info, h))
2230 {
2231 osec = sec = NULL;
2232 relocation = 0;
2233 }
2234
2235 switch (r_type)
2236 {
2237 case R_pcrel24:
2238 case R_pcrel24_jump_l:
2239 case R_byte4_data:
2240 if (! IS_FDPIC (output_bfd))
2241 goto non_fdpic;
2242
2243 case R_BFIN_GOT17M4:
2244 case R_BFIN_GOTHI:
2245 case R_BFIN_GOTLO:
2246 case R_BFIN_FUNCDESC_GOT17M4:
2247 case R_BFIN_FUNCDESC_GOTHI:
2248 case R_BFIN_FUNCDESC_GOTLO:
2249 case R_BFIN_GOTOFF17M4:
2250 case R_BFIN_GOTOFFHI:
2251 case R_BFIN_GOTOFFLO:
2252 case R_BFIN_FUNCDESC_GOTOFF17M4:
2253 case R_BFIN_FUNCDESC_GOTOFFHI:
2254 case R_BFIN_FUNCDESC_GOTOFFLO:
2255 case R_BFIN_FUNCDESC:
2256 case R_BFIN_FUNCDESC_VALUE:
2257 if (h != NULL)
2258 picrel = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info
2259 (info), input_bfd, h,
2260 orig_addend, INSERT);
2261 else
2262 /* In order to find the entry we created before, we must
2263 use the original addend, not the one that may have been
2264 modified by _bfd_elf_rela_local_sym(). */
2265 picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
2266 (info), input_bfd, r_symndx,
2267 orig_addend, INSERT);
2268 if (! picrel)
2269 return FALSE;
2270
2271 if (!_bfinfdpic_emit_got_relocs_plt_entries (picrel, output_bfd, info,
2272 osec, sym,
2273 rel->r_addend))
2274 {
2275 (*_bfd_error_handler)
2276 (_("%B: relocation at `%A+0x%x' references symbol `%s' with nonzero addend"),
2277 input_bfd, input_section, rel->r_offset, name);
2278 return FALSE;
2279
2280 }
2281
2282 break;
2283
2284 default:
2285 non_fdpic:
2286 picrel = NULL;
2287 if (h && ! BFINFDPIC_SYM_LOCAL (info, h))
2288 {
2289 info->callbacks->warning
2290 (info, _("relocation references symbol not defined in the module"),
2291 name, input_bfd, input_section, rel->r_offset);
2292 return FALSE;
2293 }
2294 break;
2295 }
2296
2297 switch (r_type)
2298 {
2299 case R_pcrel24:
2300 case R_pcrel24_jump_l:
2301 check_segment[0] = isec_segment;
2302 if (! IS_FDPIC (output_bfd))
2303 check_segment[1] = isec_segment;
2304 else if (picrel->plt)
2305 {
2306 relocation = bfinfdpic_plt_section (info)->output_section->vma
2307 + bfinfdpic_plt_section (info)->output_offset
2308 + picrel->plt_entry;
2309 check_segment[1] = plt_segment;
2310 }
2311 /* We don't want to warn on calls to undefined weak symbols,
2312 as calls to them must be protected by non-NULL tests
2313 anyway, and unprotected calls would invoke undefined
2314 behavior. */
2315 else if (picrel->symndx == -1
2316 && picrel->d.h->root.type == bfd_link_hash_undefweak)
2317 check_segment[1] = check_segment[0];
2318 else
2319 check_segment[1] = sec
2320 ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section)
2321 : (unsigned)-1;
2322 break;
2323
2324 case R_BFIN_GOT17M4:
2325 case R_BFIN_GOTHI:
2326 case R_BFIN_GOTLO:
2327 relocation = picrel->got_entry;
2328 check_segment[0] = check_segment[1] = got_segment;
2329 break;
2330
2331 case R_BFIN_FUNCDESC_GOT17M4:
2332 case R_BFIN_FUNCDESC_GOTHI:
2333 case R_BFIN_FUNCDESC_GOTLO:
2334 relocation = picrel->fdgot_entry;
2335 check_segment[0] = check_segment[1] = got_segment;
2336 break;
2337
2338 case R_BFIN_GOTOFFHI:
2339 case R_BFIN_GOTOFF17M4:
2340 case R_BFIN_GOTOFFLO:
2341 relocation -= bfinfdpic_got_section (info)->output_section->vma
2342 + bfinfdpic_got_section (info)->output_offset
2343 + bfinfdpic_got_initial_offset (info);
2344 check_segment[0] = got_segment;
2345 check_segment[1] = sec
2346 ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section)
2347 : (unsigned)-1;
2348 break;
2349
2350 case R_BFIN_FUNCDESC_GOTOFF17M4:
2351 case R_BFIN_FUNCDESC_GOTOFFHI:
2352 case R_BFIN_FUNCDESC_GOTOFFLO:
2353 relocation = picrel->fd_entry;
2354 check_segment[0] = check_segment[1] = got_segment;
2355 break;
2356
2357 case R_BFIN_FUNCDESC:
2358 {
2359 int dynindx;
2360 bfd_vma addend = rel->r_addend;
2361
2362 if (! (h && h->root.type == bfd_link_hash_undefweak
2363 && BFINFDPIC_SYM_LOCAL (info, h)))
2364 {
2365 /* If the symbol is dynamic and there may be dynamic
2366 symbol resolution because we are or are linked with a
2367 shared library, emit a FUNCDESC relocation such that
2368 the dynamic linker will allocate the function
2369 descriptor. If the symbol needs a non-local function
2370 descriptor but binds locally (e.g., its visibility is
2371 protected, emit a dynamic relocation decayed to
2372 section+offset. */
2373 if (h && ! BFINFDPIC_FUNCDESC_LOCAL (info, h)
2374 && BFINFDPIC_SYM_LOCAL (info, h)
2375 && !(info->executable && !info->pie))
2376 {
2377 dynindx = elf_section_data (h->root.u.def.section
2378 ->output_section)->dynindx;
2379 addend += h->root.u.def.section->output_offset
2380 + h->root.u.def.value;
2381 }
2382 else if (h && ! BFINFDPIC_FUNCDESC_LOCAL (info, h))
2383 {
2384 if (addend)
2385 {
2386 info->callbacks->warning
2387 (info, _("R_BFIN_FUNCDESC references dynamic symbol with nonzero addend"),
2388 name, input_bfd, input_section, rel->r_offset);
2389 return FALSE;
2390 }
2391 dynindx = h->dynindx;
2392 }
2393 else
2394 {
2395 /* Otherwise, we know we have a private function
2396 descriptor, so reference it directly. */
2397 BFD_ASSERT (picrel->privfd);
2398 r_type = R_byte4_data;
2399 dynindx = elf_section_data (bfinfdpic_got_section (info)
2400 ->output_section)->dynindx;
2401 addend = bfinfdpic_got_section (info)->output_offset
2402 + bfinfdpic_got_initial_offset (info)
2403 + picrel->fd_entry;
2404 }
2405
2406 /* If there is room for dynamic symbol resolution, emit
2407 the dynamic relocation. However, if we're linking an
2408 executable at a fixed location, we won't have emitted a
2409 dynamic symbol entry for the got section, so idx will
2410 be zero, which means we can and should compute the
2411 address of the private descriptor ourselves. */
2412 if (info->executable && !info->pie
2413 && (!h || BFINFDPIC_FUNCDESC_LOCAL (info, h)))
2414 {
2415 addend += bfinfdpic_got_section (info)->output_section->vma;
2416 if ((bfd_get_section_flags (output_bfd,
2417 input_section->output_section)
2418 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2419 {
2420 if (_bfinfdpic_osec_readonly_p (output_bfd,
2421 input_section
2422 ->output_section))
2423 {
2424 info->callbacks->warning
2425 (info,
2426 _("cannot emit fixups in read-only section"),
2427 name, input_bfd, input_section, rel->r_offset);
2428 return FALSE;
2429 }
2430 _bfinfdpic_add_rofixup (output_bfd,
2431 bfinfdpic_gotfixup_section
2432 (info),
2433 _bfd_elf_section_offset
2434 (output_bfd, info,
2435 input_section, rel->r_offset)
2436 + input_section
2437 ->output_section->vma
2438 + input_section->output_offset,
2439 picrel);
2440 }
2441 }
2442 else if ((bfd_get_section_flags (output_bfd,
2443 input_section->output_section)
2444 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2445 {
2446 bfd_vma offset;
2447
2448 if (_bfinfdpic_osec_readonly_p (output_bfd,
2449 input_section
2450 ->output_section))
2451 {
2452 info->callbacks->warning
2453 (info,
2454 _("cannot emit dynamic relocations in read-only section"),
2455 name, input_bfd, input_section, rel->r_offset);
2456 return FALSE;
2457 }
2458 offset = _bfd_elf_section_offset (output_bfd, info,
2459 input_section, rel->r_offset);
2460 /* Only output a reloc for a not deleted entry. */
2461 if (offset >= (bfd_vma) -2)
2462 _bfinfdpic_add_dyn_reloc (output_bfd,
2463 bfinfdpic_gotrel_section (info),
2464 0,
2465 R_unused0,
2466 dynindx, addend, picrel);
2467 else
2468 _bfinfdpic_add_dyn_reloc (output_bfd,
2469 bfinfdpic_gotrel_section (info),
2470 offset + input_section
2471 ->output_section->vma
2472 + input_section->output_offset,
2473 r_type,
2474 dynindx, addend, picrel);
2475 }
2476 else
2477 addend += bfinfdpic_got_section (info)->output_section->vma;
2478 }
2479
2480 /* We want the addend in-place because dynamic
2481 relocations are REL. Setting relocation to it should
2482 arrange for it to be installed. */
2483 relocation = addend - rel->r_addend;
2484 }
2485 check_segment[0] = check_segment[1] = got_segment;
2486 break;
2487
2488 case R_byte4_data:
2489 if (! IS_FDPIC (output_bfd))
2490 {
2491 check_segment[0] = check_segment[1] = -1;
2492 break;
2493 }
2494 /* Fall through. */
2495 case R_BFIN_FUNCDESC_VALUE:
2496 {
2497 int dynindx;
2498 bfd_vma addend = rel->r_addend;
2499
2500 /* If the symbol is dynamic but binds locally, use
2501 section+offset. */
2502 if (h && ! BFINFDPIC_SYM_LOCAL (info, h))
2503 {
2504 if (addend && r_type == R_BFIN_FUNCDESC_VALUE)
2505 {
2506 info->callbacks->warning
2507 (info, _("R_BFIN_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
2508 name, input_bfd, input_section, rel->r_offset);
2509 return FALSE;
2510 }
2511 dynindx = h->dynindx;
2512 }
2513 else
2514 {
2515 if (h)
2516 addend += h->root.u.def.value;
2517 else
2518 addend += sym->st_value;
2519 if (osec)
2520 addend += osec->output_offset;
2521 if (osec && osec->output_section
2522 && ! bfd_is_abs_section (osec->output_section)
2523 && ! bfd_is_und_section (osec->output_section))
2524 dynindx = elf_section_data (osec->output_section)->dynindx;
2525 else
2526 dynindx = 0;
2527 }
2528
2529 /* If we're linking an executable at a fixed address, we
2530 can omit the dynamic relocation as long as the symbol
2531 is defined in the current link unit (which is implied
2532 by its output section not being NULL). */
2533 if (info->executable && !info->pie
2534 && (!h || BFINFDPIC_SYM_LOCAL (info, h)))
2535 {
2536 if (osec)
2537 addend += osec->output_section->vma;
2538 if (IS_FDPIC (input_bfd)
2539 && (bfd_get_section_flags (output_bfd,
2540 input_section->output_section)
2541 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2542 {
2543 if (_bfinfdpic_osec_readonly_p (output_bfd,
2544 input_section
2545 ->output_section))
2546 {
2547 info->callbacks->warning
2548 (info,
2549 _("cannot emit fixups in read-only section"),
2550 name, input_bfd, input_section, rel->r_offset);
2551 return FALSE;
2552 }
2553 if (!h || h->root.type != bfd_link_hash_undefweak)
2554 {
2555 _bfinfdpic_add_rofixup (output_bfd,
2556 bfinfdpic_gotfixup_section
2557 (info),
2558 _bfd_elf_section_offset
2559 (output_bfd, info,
2560 input_section, rel->r_offset)
2561 + input_section
2562 ->output_section->vma
2563 + input_section->output_offset,
2564 picrel);
2565 if (r_type == R_BFIN_FUNCDESC_VALUE)
2566 _bfinfdpic_add_rofixup
2567 (output_bfd,
2568 bfinfdpic_gotfixup_section (info),
2569 _bfd_elf_section_offset
2570 (output_bfd, info,
2571 input_section, rel->r_offset)
2572 + input_section->output_section->vma
2573 + input_section->output_offset + 4, picrel);
2574 }
2575 }
2576 }
2577 else
2578 {
2579 if ((bfd_get_section_flags (output_bfd,
2580 input_section->output_section)
2581 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2582 {
2583 if (_bfinfdpic_osec_readonly_p (output_bfd,
2584 input_section
2585 ->output_section))
2586 {
2587 info->callbacks->warning
2588 (info,
2589 _("cannot emit dynamic relocations in read-only section"),
2590 name, input_bfd, input_section, rel->r_offset);
2591 return FALSE;
2592 }
2593 _bfinfdpic_add_dyn_reloc (output_bfd,
2594 bfinfdpic_gotrel_section (info),
2595 _bfd_elf_section_offset
2596 (output_bfd, info,
2597 input_section, rel->r_offset)
2598 + input_section
2599 ->output_section->vma
2600 + input_section->output_offset,
2601 r_type, dynindx, addend, picrel);
2602 }
2603 else if (osec)
2604 addend += osec->output_section->vma;
2605 /* We want the addend in-place because dynamic
2606 relocations are REL. Setting relocation to it
2607 should arrange for it to be installed. */
2608 relocation = addend - rel->r_addend;
2609 }
2610
2611 if (r_type == R_BFIN_FUNCDESC_VALUE)
2612 {
2613 /* If we've omitted the dynamic relocation, just emit
2614 the fixed addresses of the symbol and of the local
2615 GOT base offset. */
2616 if (info->executable && !info->pie
2617 && (!h || BFINFDPIC_SYM_LOCAL (info, h)))
2618 bfd_put_32 (output_bfd,
2619 bfinfdpic_got_section (info)->output_section->vma
2620 + bfinfdpic_got_section (info)->output_offset
2621 + bfinfdpic_got_initial_offset (info),
2622 contents + rel->r_offset + 4);
2623 else
2624 /* A function descriptor used for lazy or local
2625 resolving is initialized such that its high word
2626 contains the output section index in which the
2627 PLT entries are located, and the low word
2628 contains the offset of the lazy PLT entry entry
2629 point into that section. */
2630 bfd_put_32 (output_bfd,
2631 h && ! BFINFDPIC_SYM_LOCAL (info, h)
2632 ? 0
2633 : _bfinfdpic_osec_to_segment (output_bfd,
2634 sec
2635 ->output_section),
2636 contents + rel->r_offset + 4);
2637 }
2638 }
2639 check_segment[0] = check_segment[1] = got_segment;
2640 break;
2641
2642 default:
2643 check_segment[0] = isec_segment;
2644 check_segment[1] = sec
2645 ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section)
2646 : (unsigned)-1;
2647 break;
2648 }
2649
2650 if (check_segment[0] != check_segment[1] && IS_FDPIC (output_bfd))
2651 {
2652 #if 1 /* If you take this out, remove the #error from fdpic-static-6.d
2653 in the ld testsuite. */
2654 /* This helps catch problems in GCC while we can't do more
2655 than static linking. The idea is to test whether the
2656 input file basename is crt0.o only once. */
2657 if (silence_segment_error == 1)
2658 silence_segment_error =
2659 (strlen (input_bfd->filename) == 6
2660 && strcmp (input_bfd->filename, "crt0.o") == 0)
2661 || (strlen (input_bfd->filename) > 6
2662 && strcmp (input_bfd->filename
2663 + strlen (input_bfd->filename) - 7,
2664 "/crt0.o") == 0)
2665 ? -1 : 0;
2666 #endif
2667 if (!silence_segment_error
2668 /* We don't want duplicate errors for undefined
2669 symbols. */
2670 && !(picrel && picrel->symndx == -1
2671 && picrel->d.h->root.type == bfd_link_hash_undefined))
2672 info->callbacks->warning
2673 (info,
2674 (info->shared || info->pie)
2675 ? _("relocations between different segments are not supported")
2676 : _("warning: relocation references a different segment"),
2677 name, input_bfd, input_section, rel->r_offset);
2678 if (!silence_segment_error && (info->shared || info->pie))
2679 return FALSE;
2680 elf_elfheader (output_bfd)->e_flags |= EF_BFIN_PIC;
2681 }
2682
2683 switch (r_type)
2684 {
2685 case R_BFIN_GOTOFFHI:
2686 /* We need the addend to be applied before we shift the
2687 value right. */
2688 relocation += rel->r_addend;
2689 /* Fall through. */
2690 case R_BFIN_GOTHI:
2691 case R_BFIN_FUNCDESC_GOTHI:
2692 case R_BFIN_FUNCDESC_GOTOFFHI:
2693 relocation >>= 16;
2694 /* Fall through. */
2695
2696 case R_BFIN_GOTLO:
2697 case R_BFIN_FUNCDESC_GOTLO:
2698 case R_BFIN_GOTOFFLO:
2699 case R_BFIN_FUNCDESC_GOTOFFLO:
2700 relocation &= 0xffff;
2701 break;
2702
2703 default:
2704 break;
2705 }
2706
2707 switch (r_type)
2708 {
2709 case R_pcrel24:
2710 case R_pcrel24_jump_l:
2711 if (! IS_FDPIC (output_bfd) || ! picrel->plt)
2712 break;
2713 /* Fall through. */
2714
2715 /* When referencing a GOT entry, a function descriptor or a
2716 PLT, we don't want the addend to apply to the reference,
2717 but rather to the referenced symbol. The actual entry
2718 will have already been created taking the addend into
2719 account, so cancel it out here. */
2720 case R_BFIN_GOT17M4:
2721 case R_BFIN_GOTHI:
2722 case R_BFIN_GOTLO:
2723 case R_BFIN_FUNCDESC_GOT17M4:
2724 case R_BFIN_FUNCDESC_GOTHI:
2725 case R_BFIN_FUNCDESC_GOTLO:
2726 case R_BFIN_FUNCDESC_GOTOFF17M4:
2727 case R_BFIN_FUNCDESC_GOTOFFHI:
2728 case R_BFIN_FUNCDESC_GOTOFFLO:
2729 /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF17M4
2730 here, since we do want to apply the addend to the others.
2731 Note that we've applied the addend to GOTOFFHI before we
2732 shifted it right. */
2733 case R_BFIN_GOTOFFHI:
2734 relocation -= rel->r_addend;
2735 break;
2736
2737 default:
2738 break;
2739 }
2740
2741 if (r_type == R_pcrel24
2742 || r_type == R_pcrel24_jump_l)
2743 {
2744 bfd_vma x;
2745 bfd_vma address = rel->r_offset;
2746
2747 relocation += rel->r_addend;
2748
2749 /* Perform usual pc-relative correction. */
2750 relocation -= input_section->output_section->vma + input_section->output_offset;
2751 relocation -= address;
2752
2753 /* We are getting reloc_entry->address 2 byte off from
2754 the start of instruction. Assuming absolute postion
2755 of the reloc data. But, following code had been written assuming
2756 reloc address is starting at begining of instruction.
2757 To compensate that I have increased the value of
2758 relocation by 1 (effectively 2) and used the addr -2 instead of addr. */
2759
2760 relocation += 2;
2761 address -= 2;
2762
2763 relocation >>= 1;
2764
2765 x = bfd_get_16 (input_bfd, contents + address);
2766 x = (x & 0xff00) | ((relocation >> 16) & 0xff);
2767 bfd_put_16 (input_bfd, x, contents + address);
2768
2769 x = bfd_get_16 (input_bfd, contents + address + 2);
2770 x = relocation & 0xFFFF;
2771 bfd_put_16 (input_bfd, x, contents + address + 2);
2772 r = bfd_reloc_ok;
2773 }
2774 else
2775 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2776 contents, rel->r_offset,
2777 relocation, rel->r_addend);
2778
2779 if (r != bfd_reloc_ok)
2780 {
2781 const char * msg = (const char *) NULL;
2782
2783 switch (r)
2784 {
2785 case bfd_reloc_overflow:
2786 r = info->callbacks->reloc_overflow
2787 (info, (h ? &h->root : NULL), name, howto->name,
2788 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2789 break;
2790
2791 case bfd_reloc_undefined:
2792 r = info->callbacks->undefined_symbol
2793 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
2794 break;
2795
2796 case bfd_reloc_outofrange:
2797 msg = _("internal error: out of range error");
2798 break;
2799
2800 case bfd_reloc_notsupported:
2801 msg = _("internal error: unsupported relocation error");
2802 break;
2803
2804 case bfd_reloc_dangerous:
2805 msg = _("internal error: dangerous relocation");
2806 break;
2807
2808 default:
2809 msg = _("internal error: unknown error");
2810 break;
2811 }
2812
2813 if (msg)
2814 r = info->callbacks->warning
2815 (info, msg, name, input_bfd, input_section, rel->r_offset);
2816
2817 if (! r)
2818 return FALSE;
2819 }
2820 }
2821
2822 return TRUE;
2823 }
2824
2825 static bfd_boolean
2826 bfin_relocate_section (bfd * output_bfd,
2827 struct bfd_link_info *info,
2828 bfd * input_bfd,
2829 asection * input_section,
2830 bfd_byte * contents,
2831 Elf_Internal_Rela * relocs,
2832 Elf_Internal_Sym * local_syms,
2833 asection ** local_sections)
2834 {
2835 bfd *dynobj;
2836 Elf_Internal_Shdr *symtab_hdr;
2837 struct elf_link_hash_entry **sym_hashes;
2838 bfd_vma *local_got_offsets;
2839 asection *sgot;
2840 asection *sreloc;
2841 Elf_Internal_Rela *rel;
2842 Elf_Internal_Rela *relend;
2843 int i = 0;
2844
2845 dynobj = elf_hash_table (info)->dynobj;
2846 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2847 sym_hashes = elf_sym_hashes (input_bfd);
2848 local_got_offsets = elf_local_got_offsets (input_bfd);
2849
2850 sgot = NULL;
2851 sreloc = NULL;
2852
2853 rel = relocs;
2854 relend = relocs + input_section->reloc_count;
2855 for (; rel < relend; rel++, i++)
2856 {
2857 int r_type;
2858 reloc_howto_type *howto;
2859 unsigned long r_symndx;
2860 struct elf_link_hash_entry *h;
2861 Elf_Internal_Sym *sym;
2862 asection *sec;
2863 bfd_vma relocation = 0;
2864 bfd_boolean unresolved_reloc;
2865 bfd_reloc_status_type r;
2866 bfd_vma address;
2867
2868 r_type = ELF32_R_TYPE (rel->r_info);
2869 if (r_type < 0 || r_type >= 243)
2870 {
2871 bfd_set_error (bfd_error_bad_value);
2872 return FALSE;
2873 }
2874
2875 if (r_type == R_BFIN_GNU_VTENTRY
2876 || r_type == R_BFIN_GNU_VTINHERIT)
2877 continue;
2878
2879 howto = bfin_reloc_type_lookup (input_bfd, r_type);
2880 if (howto == NULL)
2881 {
2882 bfd_set_error (bfd_error_bad_value);
2883 return FALSE;
2884 }
2885 r_symndx = ELF32_R_SYM (rel->r_info);
2886
2887 h = NULL;
2888 sym = NULL;
2889 sec = NULL;
2890 unresolved_reloc = FALSE;
2891
2892 if (r_symndx < symtab_hdr->sh_info)
2893 {
2894 sym = local_syms + r_symndx;
2895 sec = local_sections[r_symndx];
2896 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2897 }
2898 else
2899 {
2900 bfd_boolean warned;
2901
2902 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2903 r_symndx, symtab_hdr, sym_hashes,
2904 h, sec, relocation,
2905 unresolved_reloc, warned);
2906 }
2907
2908 if (sec != NULL && elf_discarded_section (sec))
2909 {
2910 /* For relocs against symbols from removed linkonce sections,
2911 or sections discarded by a linker script, we just want the
2912 section contents zeroed. Avoid any special processing. */
2913 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2914 rel->r_info = 0;
2915 rel->r_addend = 0;
2916 continue;
2917 }
2918
2919 if (info->relocatable)
2920 continue;
2921
2922 address = rel->r_offset;
2923
2924 /* Then, process normally. */
2925 switch (r_type)
2926 {
2927 case R_BFIN_GNU_VTINHERIT:
2928 case R_BFIN_GNU_VTENTRY:
2929 return bfd_reloc_ok;
2930
2931 case R_got:
2932 /* Relocation is to the address of the entry for this symbol
2933 in the global offset table. */
2934 if (h != NULL
2935 && strcmp (h->root.root.string, "__GLOBAL_OFFSET_TABLE_") == 0)
2936 goto do_default;
2937 /* Fall through. */
2938 /* Relocation is the offset of the entry for this symbol in
2939 the global offset table. */
2940
2941 {
2942 bfd_vma off;
2943
2944 if (sgot == NULL)
2945 {
2946 sgot = bfd_get_section_by_name (dynobj, ".got");
2947 BFD_ASSERT (sgot != NULL);
2948 }
2949
2950 if (h != NULL)
2951 {
2952 bfd_boolean dyn;
2953
2954 off = h->got.offset;
2955 BFD_ASSERT (off != (bfd_vma) - 1);
2956 dyn = elf_hash_table (info)->dynamic_sections_created;
2957
2958 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2959 || (info->shared
2960 && (info->symbolic
2961 || h->dynindx == -1
2962 || h->forced_local)
2963 && h->def_regular))
2964 {
2965 /* This is actually a static link, or it is a
2966 -Bsymbolic link and the symbol is defined
2967 locally, or the symbol was forced to be local
2968 because of a version file.. We must initialize
2969 this entry in the global offset table. Since
2970 the offset must always be a multiple of 4, we
2971 use the least significant bit to record whether
2972 we have initialized it already.
2973
2974 When doing a dynamic link, we create a .rela.got
2975 relocation entry to initialize the value. This
2976 is done in the finish_dynamic_symbol routine. */
2977 if ((off & 1) != 0)
2978 off &= ~1;
2979 else
2980 {
2981 bfd_put_32 (output_bfd, relocation,
2982 sgot->contents + off);
2983 h->got.offset |= 1;
2984 }
2985 }
2986 else
2987 unresolved_reloc = FALSE;
2988 }
2989 else
2990 {
2991 BFD_ASSERT (local_got_offsets != NULL);
2992 off = local_got_offsets[r_symndx];
2993 BFD_ASSERT (off != (bfd_vma) - 1);
2994
2995 /* The offset must always be a multiple of 4. We use
2996 the least significant bit to record whether we have
2997 already generated the necessary reloc. */
2998 if ((off & 1) != 0)
2999 off &= ~1;
3000 else
3001 {
3002 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
3003
3004 if (info->shared)
3005 {
3006 asection *s;
3007 Elf_Internal_Rela outrel;
3008 bfd_byte *loc;
3009
3010 s = bfd_get_section_by_name (dynobj, ".rela.got");
3011 BFD_ASSERT (s != NULL);
3012
3013 outrel.r_offset = (sgot->output_section->vma
3014 + sgot->output_offset + off);
3015 outrel.r_info =
3016 ELF32_R_INFO (0, R_pcrel24);
3017 outrel.r_addend = relocation;
3018 loc = s->contents;
3019 loc +=
3020 s->reloc_count++ * sizeof (Elf32_External_Rela);
3021 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3022 }
3023
3024 local_got_offsets[r_symndx] |= 1;
3025 }
3026 }
3027
3028 relocation = sgot->output_offset + off;
3029 rel->r_addend = 0;
3030 /* bfin : preg = [preg + 17bitdiv4offset] relocation is div by 4. */
3031 relocation /= 4;
3032 }
3033 goto do_default;
3034
3035 case R_pcrel24:
3036 case R_pcrel24_jump_l:
3037 {
3038 bfd_vma x;
3039
3040 relocation += rel->r_addend;
3041
3042 /* Perform usual pc-relative correction. */
3043 relocation -= input_section->output_section->vma + input_section->output_offset;
3044 relocation -= address;
3045
3046 /* We are getting reloc_entry->address 2 byte off from
3047 the start of instruction. Assuming absolute postion
3048 of the reloc data. But, following code had been written assuming
3049 reloc address is starting at begining of instruction.
3050 To compensate that I have increased the value of
3051 relocation by 1 (effectively 2) and used the addr -2 instead of addr. */
3052
3053 relocation += 2;
3054 address -= 2;
3055
3056 relocation >>= 1;
3057
3058 x = bfd_get_16 (input_bfd, contents + address);
3059 x = (x & 0xff00) | ((relocation >> 16) & 0xff);
3060 bfd_put_16 (input_bfd, x, contents + address);
3061
3062 x = bfd_get_16 (input_bfd, contents + address + 2);
3063 x = relocation & 0xFFFF;
3064 bfd_put_16 (input_bfd, x, contents + address + 2);
3065 r = bfd_reloc_ok;
3066 }
3067 break;
3068
3069 default:
3070 do_default:
3071 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3072 contents, address,
3073 relocation, rel->r_addend);
3074
3075 break;
3076 }
3077
3078 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3079 because such sections are not SEC_ALLOC and thus ld.so will
3080 not process them. */
3081 if (unresolved_reloc
3082 && !((input_section->flags & SEC_DEBUGGING) != 0 && h->def_dynamic))
3083 {
3084 (*_bfd_error_handler)
3085 (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
3086 input_bfd,
3087 input_section, (long) rel->r_offset, h->root.root.string);
3088 return FALSE;
3089 }
3090
3091 if (r != bfd_reloc_ok)
3092 {
3093 const char *name;
3094
3095 if (h != NULL)
3096 name = h->root.root.string;
3097 else
3098 {
3099 name = bfd_elf_string_from_elf_section (input_bfd,
3100 symtab_hdr->sh_link,
3101 sym->st_name);
3102 if (name == NULL)
3103 return FALSE;
3104 if (*name == '\0')
3105 name = bfd_section_name (input_bfd, sec);
3106 }
3107
3108 if (r == bfd_reloc_overflow)
3109 {
3110 if (!(info->callbacks->reloc_overflow
3111 (info, (h ? &h->root : NULL), name, howto->name,
3112 (bfd_vma) 0, input_bfd, input_section, rel->r_offset)))
3113 return FALSE;
3114 }
3115 else
3116 {
3117 (*_bfd_error_handler)
3118 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3119 input_bfd, input_section,
3120 (long) rel->r_offset, name, (int) r);
3121 return FALSE;
3122 }
3123 }
3124 }
3125
3126 return TRUE;
3127 }
3128
3129 static asection *
3130 bfin_gc_mark_hook (asection * sec,
3131 struct bfd_link_info *info,
3132 Elf_Internal_Rela * rel,
3133 struct elf_link_hash_entry *h,
3134 Elf_Internal_Sym * sym)
3135 {
3136 if (h != NULL)
3137 switch (ELF32_R_TYPE (rel->r_info))
3138 {
3139 case R_BFIN_GNU_VTINHERIT:
3140 case R_BFIN_GNU_VTENTRY:
3141 return NULL;
3142 }
3143
3144 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
3145 }
3146
3147 /* Update the got entry reference counts for the section being removed. */
3148
3149 static bfd_boolean
3150 bfin_gc_sweep_hook (bfd * abfd,
3151 struct bfd_link_info *info,
3152 asection * sec,
3153 const Elf_Internal_Rela * relocs)
3154 {
3155 Elf_Internal_Shdr *symtab_hdr;
3156 struct elf_link_hash_entry **sym_hashes;
3157 bfd_signed_vma *local_got_refcounts;
3158 const Elf_Internal_Rela *rel, *relend;
3159 bfd *dynobj;
3160 asection *sgot;
3161 asection *srelgot;
3162
3163 dynobj = elf_hash_table (info)->dynobj;
3164 if (dynobj == NULL)
3165 return TRUE;
3166
3167 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3168 sym_hashes = elf_sym_hashes (abfd);
3169 local_got_refcounts = elf_local_got_refcounts (abfd);
3170
3171 sgot = bfd_get_section_by_name (dynobj, ".got");
3172 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3173
3174 relend = relocs + sec->reloc_count;
3175 for (rel = relocs; rel < relend; rel++)
3176 {
3177 unsigned long r_symndx;
3178 struct elf_link_hash_entry *h;
3179
3180 switch (ELF32_R_TYPE (rel->r_info))
3181 {
3182 case R_got:
3183 r_symndx = ELF32_R_SYM (rel->r_info);
3184 if (r_symndx >= symtab_hdr->sh_info)
3185 {
3186 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3187 if (h->got.refcount > 0)
3188 {
3189 --h->got.refcount;
3190 if (h->got.refcount == 0)
3191 {
3192 /* We don't need the .got entry any more. */
3193 sgot->size -= 4;
3194 srelgot->size -= sizeof (Elf32_External_Rela);
3195 }
3196 }
3197 }
3198 else if (local_got_refcounts != NULL)
3199 {
3200 if (local_got_refcounts[r_symndx] > 0)
3201 {
3202 --local_got_refcounts[r_symndx];
3203 if (local_got_refcounts[r_symndx] == 0)
3204 {
3205 /* We don't need the .got entry any more. */
3206 sgot->size -= 4;
3207 if (info->shared)
3208 srelgot->size -= sizeof (Elf32_External_Rela);
3209 }
3210 }
3211 }
3212 break;
3213 default:
3214 break;
3215 }
3216 }
3217 return TRUE;
3218 }
3219
3220 /* We need dynamic symbols for every section, since segments can
3221 relocate independently. */
3222 static bfd_boolean
3223 _bfinfdpic_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
3224 struct bfd_link_info *info
3225 ATTRIBUTE_UNUSED,
3226 asection *p ATTRIBUTE_UNUSED)
3227 {
3228 switch (elf_section_data (p)->this_hdr.sh_type)
3229 {
3230 case SHT_PROGBITS:
3231 case SHT_NOBITS:
3232 /* If sh_type is yet undecided, assume it could be
3233 SHT_PROGBITS/SHT_NOBITS. */
3234 case SHT_NULL:
3235 return FALSE;
3236
3237 /* There shouldn't be section relative relocations
3238 against any other section. */
3239 default:
3240 return TRUE;
3241 }
3242 }
3243
3244 /* Create a .got section, as well as its additional info field. This
3245 is almost entirely copied from
3246 elflink.c:_bfd_elf_create_got_section(). */
3247
3248 static bfd_boolean
3249 _bfin_create_got_section (bfd *abfd, struct bfd_link_info *info)
3250 {
3251 flagword flags, pltflags;
3252 asection *s;
3253 struct elf_link_hash_entry *h;
3254 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3255 int ptralign;
3256 int offset;
3257
3258 /* This function may be called more than once. */
3259 s = bfd_get_section_by_name (abfd, ".got");
3260 if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
3261 return TRUE;
3262
3263 /* Machine specific: although pointers are 32-bits wide, we want the
3264 GOT to be aligned to a 64-bit boundary, such that function
3265 descriptors in it can be accessed with 64-bit loads and
3266 stores. */
3267 ptralign = 3;
3268
3269 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3270 | SEC_LINKER_CREATED);
3271 pltflags = flags;
3272
3273 s = bfd_make_section_with_flags (abfd, ".got", flags);
3274 if (s == NULL
3275 || !bfd_set_section_alignment (abfd, s, ptralign))
3276 return FALSE;
3277
3278 if (bed->want_got_plt)
3279 {
3280 s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
3281 if (s == NULL
3282 || !bfd_set_section_alignment (abfd, s, ptralign))
3283 return FALSE;
3284 }
3285
3286 if (bed->want_got_sym)
3287 {
3288 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
3289 (or .got.plt) section. We don't do this in the linker script
3290 because we don't want to define the symbol if we are not creating
3291 a global offset table. */
3292 h = _bfd_elf_define_linkage_sym (abfd, info, s, "__GLOBAL_OFFSET_TABLE_");
3293 elf_hash_table (info)->hgot = h;
3294 if (h == NULL)
3295 return FALSE;
3296
3297 /* Machine-specific: we want the symbol for executables as
3298 well. */
3299 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3300 return FALSE;
3301 }
3302
3303 /* The first bit of the global offset table is the header. */
3304 s->size += bed->got_header_size;
3305
3306 /* This is the machine-specific part. Create and initialize section
3307 data for the got. */
3308 if (IS_FDPIC (abfd))
3309 {
3310 bfinfdpic_got_section (info) = s;
3311 bfinfdpic_relocs_info (info) = htab_try_create (1,
3312 bfinfdpic_relocs_info_hash,
3313 bfinfdpic_relocs_info_eq,
3314 (htab_del) NULL);
3315 if (! bfinfdpic_relocs_info (info))
3316 return FALSE;
3317
3318 s = bfd_make_section_with_flags (abfd, ".rel.got",
3319 (flags | SEC_READONLY));
3320 if (s == NULL
3321 || ! bfd_set_section_alignment (abfd, s, 2))
3322 return FALSE;
3323
3324 bfinfdpic_gotrel_section (info) = s;
3325
3326 /* Machine-specific. */
3327 s = bfd_make_section_with_flags (abfd, ".rofixup",
3328 (flags | SEC_READONLY));
3329 if (s == NULL
3330 || ! bfd_set_section_alignment (abfd, s, 2))
3331 return FALSE;
3332
3333 bfinfdpic_gotfixup_section (info) = s;
3334 offset = -2048;
3335 flags = BSF_GLOBAL;
3336 }
3337 else
3338 {
3339 offset = 2048;
3340 flags = BSF_GLOBAL | BSF_WEAK;
3341 }
3342
3343 return TRUE;
3344 }
3345
3346 /* Make sure the got and plt sections exist, and that our pointers in
3347 the link hash table point to them. */
3348
3349 static bfd_boolean
3350 elf32_bfinfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3351 {
3352 /* This is mostly copied from
3353 elflink.c:_bfd_elf_create_dynamic_sections(). */
3354 flagword flags, pltflags;
3355 asection *s;
3356 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3357
3358 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3359 .rel[a].bss sections. */
3360
3361 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3362 | SEC_LINKER_CREATED);
3363
3364 pltflags = flags;
3365 pltflags |= SEC_CODE;
3366 if (bed->plt_not_loaded)
3367 pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
3368 if (bed->plt_readonly)
3369 pltflags |= SEC_READONLY;
3370
3371 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
3372 if (s == NULL
3373 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3374 return FALSE;
3375 /* Blackfin-specific: remember it. */
3376 bfinfdpic_plt_section (info) = s;
3377
3378 if (bed->want_plt_sym)
3379 {
3380 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3381 .plt section. */
3382 struct elf_link_hash_entry *h;
3383 struct bfd_link_hash_entry *bh = NULL;
3384
3385 if (! (_bfd_generic_link_add_one_symbol
3386 (info, abfd, "__PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 0, NULL,
3387 FALSE, get_elf_backend_data (abfd)->collect, &bh)))
3388 return FALSE;
3389 h = (struct elf_link_hash_entry *) bh;
3390 h->def_regular = 1;
3391 h->type = STT_OBJECT;
3392
3393 if (! info->executable
3394 && ! bfd_elf_link_record_dynamic_symbol (info, h))
3395 return FALSE;
3396 }
3397
3398 /* Blackfin-specific: we want rel relocations for the plt. */
3399 s = bfd_make_section_with_flags (abfd, ".rel.plt", flags | SEC_READONLY);
3400 if (s == NULL
3401 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
3402 return FALSE;
3403 /* Blackfin-specific: remember it. */
3404 bfinfdpic_pltrel_section (info) = s;
3405
3406 /* Blackfin-specific: we want to create the GOT in the Blackfin way. */
3407 if (! _bfin_create_got_section (abfd, info))
3408 return FALSE;
3409
3410 /* Blackfin-specific: make sure we created everything we wanted. */
3411 BFD_ASSERT (bfinfdpic_got_section (info) && bfinfdpic_gotrel_section (info)
3412 /* && bfinfdpic_gotfixup_section (info) */
3413 && bfinfdpic_plt_section (info)
3414 && bfinfdpic_pltrel_section (info));
3415
3416 if (bed->want_dynbss)
3417 {
3418 /* The .dynbss section is a place to put symbols which are defined
3419 by dynamic objects, are referenced by regular objects, and are
3420 not functions. We must allocate space for them in the process
3421 image and use a R_*_COPY reloc to tell the dynamic linker to
3422 initialize them at run time. The linker script puts the .dynbss
3423 section into the .bss section of the final image. */
3424 s = bfd_make_section_with_flags (abfd, ".dynbss",
3425 SEC_ALLOC | SEC_LINKER_CREATED);
3426 if (s == NULL)
3427 return FALSE;
3428
3429 /* The .rel[a].bss section holds copy relocs. This section is not
3430 normally needed. We need to create it here, though, so that the
3431 linker will map it to an output section. We can't just create it
3432 only if we need it, because we will not know whether we need it
3433 until we have seen all the input files, and the first time the
3434 main linker code calls BFD after examining all the input files
3435 (size_dynamic_sections) the input sections have already been
3436 mapped to the output sections. If the section turns out not to
3437 be needed, we can discard it later. We will never need this
3438 section when generating a shared object, since they do not use
3439 copy relocs. */
3440 if (! info->shared)
3441 {
3442 s = bfd_make_section_with_flags (abfd,
3443 (bed->default_use_rela_p
3444 ? ".rela.bss" : ".rel.bss"),
3445 flags | SEC_READONLY);
3446 if (s == NULL
3447 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
3448 return FALSE;
3449 }
3450 }
3451
3452 return TRUE;
3453 }
3454
3455 /* The name of the dynamic interpreter. This is put in the .interp
3456 section. */
3457
3458 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
3459
3460 #define DEFAULT_STACK_SIZE 0x20000
3461
3462 /* This structure is used to collect the number of entries present in
3463 each addressable range of the got. */
3464 struct _bfinfdpic_dynamic_got_info
3465 {
3466 /* Several bits of information about the current link. */
3467 struct bfd_link_info *info;
3468 /* Total size needed for GOT entries within the 18- or 32-bit
3469 ranges. */
3470 bfd_vma got17m4, gothilo;
3471 /* Total size needed for function descriptor entries within the 18-
3472 or 32-bit ranges. */
3473 bfd_vma fd17m4, fdhilo;
3474 /* Total size needed function descriptor entries referenced in PLT
3475 entries, that would be profitable to place in offsets close to
3476 the PIC register. */
3477 bfd_vma fdplt;
3478 /* Total size needed by lazy PLT entries. */
3479 bfd_vma lzplt;
3480 /* Number of relocations carried over from input object files. */
3481 unsigned long relocs;
3482 /* Number of fixups introduced by relocations in input object files. */
3483 unsigned long fixups;
3484 };
3485
3486 /* Compute the total GOT size required by each symbol in each range.
3487 Symbols may require up to 4 words in the GOT: an entry pointing to
3488 the symbol, an entry pointing to its function descriptor, and a
3489 private function descriptors taking two words. */
3490
3491 static int
3492 _bfinfdpic_count_got_plt_entries (void **entryp, void *dinfo_)
3493 {
3494 struct bfinfdpic_relocs_info *entry = *entryp;
3495 struct _bfinfdpic_dynamic_got_info *dinfo = dinfo_;
3496 unsigned relocs = 0, fixups = 0;
3497
3498 /* Allocate space for a GOT entry pointing to the symbol. */
3499 if (entry->got17m4)
3500 dinfo->got17m4 += 4;
3501 else if (entry->gothilo)
3502 dinfo->gothilo += 4;
3503 else
3504 entry->relocs32--;
3505 entry->relocs32++;
3506
3507 /* Allocate space for a GOT entry pointing to the function
3508 descriptor. */
3509 if (entry->fdgot17m4)
3510 dinfo->got17m4 += 4;
3511 else if (entry->fdgothilo)
3512 dinfo->gothilo += 4;
3513 else
3514 entry->relocsfd--;
3515 entry->relocsfd++;
3516
3517 /* Decide whether we need a PLT entry, a function descriptor in the
3518 GOT, and a lazy PLT entry for this symbol. */
3519 entry->plt = entry->call
3520 && entry->symndx == -1 && ! BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
3521 && elf_hash_table (dinfo->info)->dynamic_sections_created;
3522 entry->privfd = entry->plt
3523 || entry->fdgoff17m4 || entry->fdgoffhilo
3524 || ((entry->fd || entry->fdgot17m4 || entry->fdgothilo)
3525 && (entry->symndx != -1
3526 || BFINFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
3527 entry->lazyplt = entry->privfd
3528 && entry->symndx == -1 && ! BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
3529 && ! (dinfo->info->flags & DF_BIND_NOW)
3530 && elf_hash_table (dinfo->info)->dynamic_sections_created;
3531
3532 /* Allocate space for a function descriptor. */
3533 if (entry->fdgoff17m4)
3534 dinfo->fd17m4 += 8;
3535 else if (entry->privfd && entry->plt)
3536 dinfo->fdplt += 8;
3537 else if (entry->privfd)
3538 dinfo->fdhilo += 8;
3539 else
3540 entry->relocsfdv--;
3541 entry->relocsfdv++;
3542
3543 if (entry->lazyplt)
3544 dinfo->lzplt += LZPLT_NORMAL_SIZE;
3545
3546 if (!dinfo->info->executable || dinfo->info->pie)
3547 relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv;
3548 else
3549 {
3550 if (entry->symndx != -1 || BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))
3551 {
3552 if (entry->symndx != -1
3553 || entry->d.h->root.type != bfd_link_hash_undefweak)
3554 fixups += entry->relocs32 + 2 * entry->relocsfdv;
3555 }
3556 else
3557 relocs += entry->relocs32 + entry->relocsfdv;
3558
3559 if (entry->symndx != -1
3560 || BFINFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
3561 {
3562 if (entry->symndx != -1
3563 || entry->d.h->root.type != bfd_link_hash_undefweak)
3564 fixups += entry->relocsfd;
3565 }
3566 else
3567 relocs += entry->relocsfd;
3568 }
3569
3570 entry->dynrelocs += relocs;
3571 entry->fixups += fixups;
3572 dinfo->relocs += relocs;
3573 dinfo->fixups += fixups;
3574
3575 return 1;
3576 }
3577
3578 /* This structure is used to assign offsets to got entries, function
3579 descriptors, plt entries and lazy plt entries. */
3580
3581 struct _bfinfdpic_dynamic_got_plt_info
3582 {
3583 /* Summary information collected with _bfinfdpic_count_got_plt_entries. */
3584 struct _bfinfdpic_dynamic_got_info g;
3585
3586 /* For each addressable range, we record a MAX (positive) and MIN
3587 (negative) value. CUR is used to assign got entries, and it's
3588 incremented from an initial positive value to MAX, then from MIN
3589 to FDCUR (unless FDCUR wraps around first). FDCUR is used to
3590 assign function descriptors, and it's decreased from an initial
3591 non-positive value to MIN, then from MAX down to CUR (unless CUR
3592 wraps around first). All of MIN, MAX, CUR and FDCUR always point
3593 to even words. ODD, if non-zero, indicates an odd word to be
3594 used for the next got entry, otherwise CUR is used and
3595 incremented by a pair of words, wrapping around when it reaches
3596 MAX. FDCUR is decremented (and wrapped) before the next function
3597 descriptor is chosen. FDPLT indicates the number of remaining
3598 slots that can be used for function descriptors used only by PLT
3599 entries. */
3600 struct _bfinfdpic_dynamic_got_alloc_data
3601 {
3602 bfd_signed_vma max, cur, odd, fdcur, min;
3603 bfd_vma fdplt;
3604 } got17m4, gothilo;
3605 };
3606
3607 /* Determine the positive and negative ranges to be used by each
3608 offset range in the GOT. FDCUR and CUR, that must be aligned to a
3609 double-word boundary, are the minimum (negative) and maximum
3610 (positive) GOT offsets already used by previous ranges, except for
3611 an ODD entry that may have been left behind. GOT and FD indicate
3612 the size of GOT entries and function descriptors that must be
3613 placed within the range from -WRAP to WRAP. If there's room left,
3614 up to FDPLT bytes should be reserved for additional function
3615 descriptors. */
3616
3617 inline static bfd_signed_vma
3618 _bfinfdpic_compute_got_alloc_data (struct _bfinfdpic_dynamic_got_alloc_data *gad,
3619 bfd_signed_vma fdcur,
3620 bfd_signed_vma odd,
3621 bfd_signed_vma cur,
3622 bfd_vma got,
3623 bfd_vma fd,
3624 bfd_vma fdplt,
3625 bfd_vma wrap)
3626 {
3627 bfd_signed_vma wrapmin = -wrap;
3628
3629 /* Start at the given initial points. */
3630 gad->fdcur = fdcur;
3631 gad->cur = cur;
3632
3633 /* If we had an incoming odd word and we have any got entries that
3634 are going to use it, consume it, otherwise leave gad->odd at
3635 zero. We might force gad->odd to zero and return the incoming
3636 odd such that it is used by the next range, but then GOT entries
3637 might appear to be out of order and we wouldn't be able to
3638 shorten the GOT by one word if it turns out to end with an
3639 unpaired GOT entry. */
3640 if (odd && got)
3641 {
3642 gad->odd = odd;
3643 got -= 4;
3644 odd = 0;
3645 }
3646 else
3647 gad->odd = 0;
3648
3649 /* If we're left with an unpaired GOT entry, compute its location
3650 such that we can return it. Otherwise, if got doesn't require an
3651 odd number of words here, either odd was already zero in the
3652 block above, or it was set to zero because got was non-zero, or
3653 got was already zero. In the latter case, we want the value of
3654 odd to carry over to the return statement, so we don't want to
3655 reset odd unless the condition below is true. */
3656 if (got & 4)
3657 {
3658 odd = cur + got;
3659 got += 4;
3660 }
3661
3662 /* Compute the tentative boundaries of this range. */
3663 gad->max = cur + got;
3664 gad->min = fdcur - fd;
3665 gad->fdplt = 0;
3666
3667 /* If function descriptors took too much space, wrap some of them
3668 around. */
3669 if (gad->min < wrapmin)
3670 {
3671 gad->max += wrapmin - gad->min;
3672 gad->min = wrapmin;
3673 }
3674 /* If there is space left and we have function descriptors
3675 referenced in PLT entries that could take advantage of shorter
3676 offsets, place them here. */
3677 else if (fdplt && gad->min > wrapmin)
3678 {
3679 bfd_vma fds;
3680 if ((bfd_vma) (gad->min - wrapmin) < fdplt)
3681 fds = gad->min - wrapmin;
3682 else
3683 fds = fdplt;
3684
3685 fdplt -= fds;
3686 gad->min -= fds;
3687 gad->fdplt += fds;
3688 }
3689
3690 /* If GOT entries took too much space, wrap some of them around.
3691 This may well cause gad->min to become lower than wrapmin. This
3692 will cause a relocation overflow later on, so we don't have to
3693 report it here . */
3694 if ((bfd_vma) gad->max > wrap)
3695 {
3696 gad->min -= gad->max - wrap;
3697 gad->max = wrap;
3698 }
3699 /* If there is more space left, try to place some more function
3700 descriptors for PLT entries. */
3701 else if (fdplt && (bfd_vma) gad->max < wrap)
3702 {
3703 bfd_vma fds;
3704 if ((bfd_vma) (wrap - gad->max) < fdplt)
3705 fds = wrap - gad->max;
3706 else
3707 fds = fdplt;
3708
3709 fdplt -= fds;
3710 gad->max += fds;
3711 gad->fdplt += fds;
3712 }
3713
3714 /* If odd was initially computed as an offset past the wrap point,
3715 wrap it around. */
3716 if (odd > gad->max)
3717 odd = gad->min + odd - gad->max;
3718
3719 /* _bfinfdpic_get_got_entry() below will always wrap gad->cur if needed
3720 before returning, so do it here too. This guarantees that,
3721 should cur and fdcur meet at the wrap point, they'll both be
3722 equal to min. */
3723 if (gad->cur == gad->max)
3724 gad->cur = gad->min;
3725
3726 return odd;
3727 }
3728
3729 /* Compute the location of the next GOT entry, given the allocation
3730 data for a range. */
3731
3732 inline static bfd_signed_vma
3733 _bfinfdpic_get_got_entry (struct _bfinfdpic_dynamic_got_alloc_data *gad)
3734 {
3735 bfd_signed_vma ret;
3736
3737 if (gad->odd)
3738 {
3739 /* If there was an odd word left behind, use it. */
3740 ret = gad->odd;
3741 gad->odd = 0;
3742 }
3743 else
3744 {
3745 /* Otherwise, use the word pointed to by cur, reserve the next
3746 as an odd word, and skip to the next pair of words, possibly
3747 wrapping around. */
3748 ret = gad->cur;
3749 gad->odd = gad->cur + 4;
3750 gad->cur += 8;
3751 if (gad->cur == gad->max)
3752 gad->cur = gad->min;
3753 }
3754
3755 return ret;
3756 }
3757
3758 /* Compute the location of the next function descriptor entry in the
3759 GOT, given the allocation data for a range. */
3760
3761 inline static bfd_signed_vma
3762 _bfinfdpic_get_fd_entry (struct _bfinfdpic_dynamic_got_alloc_data *gad)
3763 {
3764 /* If we're at the bottom, wrap around, and only then allocate the
3765 next pair of words. */
3766 if (gad->fdcur == gad->min)
3767 gad->fdcur = gad->max;
3768 return gad->fdcur -= 8;
3769 }
3770
3771 /* Assign GOT offsets for every GOT entry and function descriptor.
3772 Doing everything in a single pass is tricky. */
3773
3774 static int
3775 _bfinfdpic_assign_got_entries (void **entryp, void *info_)
3776 {
3777 struct bfinfdpic_relocs_info *entry = *entryp;
3778 struct _bfinfdpic_dynamic_got_plt_info *dinfo = info_;
3779
3780 if (entry->got17m4)
3781 entry->got_entry = _bfinfdpic_get_got_entry (&dinfo->got17m4);
3782 else if (entry->gothilo)
3783 entry->got_entry = _bfinfdpic_get_got_entry (&dinfo->gothilo);
3784
3785 if (entry->fdgot17m4)
3786 entry->fdgot_entry = _bfinfdpic_get_got_entry (&dinfo->got17m4);
3787 else if (entry->fdgothilo)
3788 entry->fdgot_entry = _bfinfdpic_get_got_entry (&dinfo->gothilo);
3789
3790 if (entry->fdgoff17m4)
3791 entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3792 else if (entry->plt && dinfo->got17m4.fdplt)
3793 {
3794 dinfo->got17m4.fdplt -= 8;
3795 entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3796 }
3797 else if (entry->plt)
3798 {
3799 dinfo->gothilo.fdplt -= 8;
3800 entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3801 }
3802 else if (entry->privfd)
3803 entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3804
3805 return 1;
3806 }
3807
3808 /* Assign GOT offsets to private function descriptors used by PLT
3809 entries (or referenced by 32-bit offsets), as well as PLT entries
3810 and lazy PLT entries. */
3811
3812 static int
3813 _bfinfdpic_assign_plt_entries (void **entryp, void *info_)
3814 {
3815 struct bfinfdpic_relocs_info *entry = *entryp;
3816 struct _bfinfdpic_dynamic_got_plt_info *dinfo = info_;
3817
3818 /* If this symbol requires a local function descriptor, allocate
3819 one. */
3820 if (entry->privfd && entry->fd_entry == 0)
3821 {
3822 if (dinfo->got17m4.fdplt)
3823 {
3824 entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3825 dinfo->got17m4.fdplt -= 8;
3826 }
3827 else
3828 {
3829 BFD_ASSERT (dinfo->gothilo.fdplt);
3830 entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3831 dinfo->gothilo.fdplt -= 8;
3832 }
3833 }
3834
3835 if (entry->plt)
3836 {
3837 int size;
3838
3839 /* We use the section's raw size to mark the location of the
3840 next PLT entry. */
3841 entry->plt_entry = bfinfdpic_plt_section (dinfo->g.info)->size;
3842
3843 /* Figure out the length of this PLT entry based on the
3844 addressing mode we need to reach the function descriptor. */
3845 BFD_ASSERT (entry->fd_entry);
3846 if (entry->fd_entry >= -(1 << (18 - 1))
3847 && entry->fd_entry + 4 < (1 << (18 - 1)))
3848 size = 10;
3849 else
3850 size = 16;
3851
3852 bfinfdpic_plt_section (dinfo->g.info)->size += size;
3853 }
3854
3855 if (entry->lazyplt)
3856 {
3857 entry->lzplt_entry = dinfo->g.lzplt;
3858 dinfo->g.lzplt += LZPLT_NORMAL_SIZE;
3859 /* If this entry is the one that gets the resolver stub, account
3860 for the additional instruction. */
3861 if (entry->lzplt_entry % BFINFDPIC_LZPLT_BLOCK_SIZE
3862 == BFINFDPIC_LZPLT_RESOLV_LOC)
3863 dinfo->g.lzplt += LZPLT_RESOLVER_EXTRA;
3864 }
3865
3866 return 1;
3867 }
3868
3869 /* Follow indirect and warning hash entries so that each got entry
3870 points to the final symbol definition. P must point to a pointer
3871 to the hash table we're traversing. Since this traversal may
3872 modify the hash table, we set this pointer to NULL to indicate
3873 we've made a potentially-destructive change to the hash table, so
3874 the traversal must be restarted. */
3875 static int
3876 _bfinfdpic_resolve_final_relocs_info (void **entryp, void *p)
3877 {
3878 struct bfinfdpic_relocs_info *entry = *entryp;
3879 htab_t *htab = p;
3880
3881 if (entry->symndx == -1)
3882 {
3883 struct elf_link_hash_entry *h = entry->d.h;
3884 struct bfinfdpic_relocs_info *oentry;
3885
3886 while (h->root.type == bfd_link_hash_indirect
3887 || h->root.type == bfd_link_hash_warning)
3888 h = (struct elf_link_hash_entry *)h->root.u.i.link;
3889
3890 if (entry->d.h == h)
3891 return 1;
3892
3893 oentry = bfinfdpic_relocs_info_for_global (*htab, 0, h, entry->addend,
3894 NO_INSERT);
3895
3896 if (oentry)
3897 {
3898 /* Merge the two entries. */
3899 bfinfdpic_pic_merge_early_relocs_info (oentry, entry);
3900 htab_clear_slot (*htab, entryp);
3901 return 1;
3902 }
3903
3904 entry->d.h = h;
3905
3906 /* If we can't find this entry with the new bfd hash, re-insert
3907 it, and get the traversal restarted. */
3908 if (! htab_find (*htab, entry))
3909 {
3910 htab_clear_slot (*htab, entryp);
3911 entryp = htab_find_slot (*htab, entry, INSERT);
3912 if (! *entryp)
3913 *entryp = entry;
3914 /* Abort the traversal, since the whole table may have
3915 moved, and leave it up to the parent to restart the
3916 process. */
3917 *(htab_t *)p = NULL;
3918 return 0;
3919 }
3920 }
3921
3922 return 1;
3923 }
3924
3925 /* Set the sizes of the dynamic sections. */
3926
3927 static bfd_boolean
3928 elf32_bfinfdpic_size_dynamic_sections (bfd *output_bfd,
3929 struct bfd_link_info *info)
3930 {
3931 bfd *dynobj;
3932 asection *s;
3933 struct _bfinfdpic_dynamic_got_plt_info gpinfo;
3934 bfd_signed_vma odd;
3935 bfd_vma limit;
3936
3937 dynobj = elf_hash_table (info)->dynobj;
3938 BFD_ASSERT (dynobj != NULL);
3939
3940 if (elf_hash_table (info)->dynamic_sections_created)
3941 {
3942 /* Set the contents of the .interp section to the interpreter. */
3943 if (info->executable)
3944 {
3945 s = bfd_get_section_by_name (dynobj, ".interp");
3946 BFD_ASSERT (s != NULL);
3947 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3948 s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
3949 }
3950 }
3951
3952 memset (&gpinfo, 0, sizeof (gpinfo));
3953 gpinfo.g.info = info;
3954
3955 for (;;)
3956 {
3957 htab_t relocs = bfinfdpic_relocs_info (info);
3958
3959 htab_traverse (relocs, _bfinfdpic_resolve_final_relocs_info, &relocs);
3960
3961 if (relocs == bfinfdpic_relocs_info (info))
3962 break;
3963 }
3964
3965 htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_count_got_plt_entries,
3966 &gpinfo.g);
3967
3968 odd = 12;
3969 /* Compute the total size taken by entries in the 18-bit range,
3970 to tell how many PLT function descriptors we can bring into it
3971 without causing it to overflow. */
3972 limit = odd + gpinfo.g.got17m4 + gpinfo.g.fd17m4;
3973 if (limit < (bfd_vma)1 << 18)
3974 limit = ((bfd_vma)1 << 18) - limit;
3975 else
3976 limit = 0;
3977 if (gpinfo.g.fdplt < limit)
3978 limit = gpinfo.g.fdplt;
3979
3980 /* Determine the ranges of GOT offsets that we can use for each
3981 range of addressing modes. */
3982 odd = _bfinfdpic_compute_got_alloc_data (&gpinfo.got17m4,
3983 0,
3984 odd,
3985 16,
3986 gpinfo.g.got17m4,
3987 gpinfo.g.fd17m4,
3988 limit,
3989 (bfd_vma)1 << (18-1));
3990 odd = _bfinfdpic_compute_got_alloc_data (&gpinfo.gothilo,
3991 gpinfo.got17m4.min,
3992 odd,
3993 gpinfo.got17m4.max,
3994 gpinfo.g.gothilo,
3995 gpinfo.g.fdhilo,
3996 gpinfo.g.fdplt - gpinfo.got17m4.fdplt,
3997 (bfd_vma)1 << (32-1));
3998
3999 /* Now assign (most) GOT offsets. */
4000 htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_assign_got_entries,
4001 &gpinfo);
4002
4003 bfinfdpic_got_section (info)->size = gpinfo.gothilo.max
4004 - gpinfo.gothilo.min
4005 /* If an odd word is the last word of the GOT, we don't need this
4006 word to be part of the GOT. */
4007 - (odd + 4 == gpinfo.gothilo.max ? 4 : 0);
4008 if (bfinfdpic_got_section (info)->size == 0)
4009 bfinfdpic_got_section (info)->flags |= SEC_EXCLUDE;
4010 else if (bfinfdpic_got_section (info)->size == 12
4011 && ! elf_hash_table (info)->dynamic_sections_created)
4012 {
4013 bfinfdpic_got_section (info)->flags |= SEC_EXCLUDE;
4014 bfinfdpic_got_section (info)->size = 0;
4015 }
4016 else
4017 {
4018 bfinfdpic_got_section (info)->contents =
4019 (bfd_byte *) bfd_zalloc (dynobj,
4020 bfinfdpic_got_section (info)->size);
4021 if (bfinfdpic_got_section (info)->contents == NULL)
4022 return FALSE;
4023 }
4024
4025 if (elf_hash_table (info)->dynamic_sections_created)
4026 /* Subtract the number of lzplt entries, since those will generate
4027 relocations in the pltrel section. */
4028 bfinfdpic_gotrel_section (info)->size =
4029 (gpinfo.g.relocs - gpinfo.g.lzplt / LZPLT_NORMAL_SIZE)
4030 * get_elf_backend_data (output_bfd)->s->sizeof_rel;
4031 else
4032 BFD_ASSERT (gpinfo.g.relocs == 0);
4033 if (bfinfdpic_gotrel_section (info)->size == 0)
4034 bfinfdpic_gotrel_section (info)->flags |= SEC_EXCLUDE;
4035 else
4036 {
4037 bfinfdpic_gotrel_section (info)->contents =
4038 (bfd_byte *) bfd_zalloc (dynobj,
4039 bfinfdpic_gotrel_section (info)->size);
4040 if (bfinfdpic_gotrel_section (info)->contents == NULL)
4041 return FALSE;
4042 }
4043
4044 bfinfdpic_gotfixup_section (info)->size = (gpinfo.g.fixups + 1) * 4;
4045 if (bfinfdpic_gotfixup_section (info)->size == 0)
4046 bfinfdpic_gotfixup_section (info)->flags |= SEC_EXCLUDE;
4047 else
4048 {
4049 bfinfdpic_gotfixup_section (info)->contents =
4050 (bfd_byte *) bfd_zalloc (dynobj,
4051 bfinfdpic_gotfixup_section (info)->size);
4052 if (bfinfdpic_gotfixup_section (info)->contents == NULL)
4053 return FALSE;
4054 }
4055
4056 if (elf_hash_table (info)->dynamic_sections_created)
4057 {
4058 bfinfdpic_pltrel_section (info)->size =
4059 gpinfo.g.lzplt / LZPLT_NORMAL_SIZE * get_elf_backend_data (output_bfd)->s->sizeof_rel;
4060 if (bfinfdpic_pltrel_section (info)->size == 0)
4061 bfinfdpic_pltrel_section (info)->flags |= SEC_EXCLUDE;
4062 else
4063 {
4064 bfinfdpic_pltrel_section (info)->contents =
4065 (bfd_byte *) bfd_zalloc (dynobj,
4066 bfinfdpic_pltrel_section (info)->size);
4067 if (bfinfdpic_pltrel_section (info)->contents == NULL)
4068 return FALSE;
4069 }
4070 }
4071
4072 /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
4073 such that there's room for the additional instruction needed to
4074 call the resolver. Since _bfinfdpic_assign_got_entries didn't
4075 account for them, our block size is 4 bytes smaller than the real
4076 block size. */
4077 if (elf_hash_table (info)->dynamic_sections_created)
4078 {
4079 bfinfdpic_plt_section (info)->size = gpinfo.g.lzplt
4080 + ((gpinfo.g.lzplt + (BFINFDPIC_LZPLT_BLOCK_SIZE - 4) - LZPLT_NORMAL_SIZE)
4081 / (BFINFDPIC_LZPLT_BLOCK_SIZE - 4) * LZPLT_RESOLVER_EXTRA);
4082 }
4083
4084 /* Reset it, such that _bfinfdpic_assign_plt_entries() can use it to
4085 actually assign lazy PLT entries addresses. */
4086 gpinfo.g.lzplt = 0;
4087
4088 /* Save information that we're going to need to generate GOT and PLT
4089 entries. */
4090 bfinfdpic_got_initial_offset (info) = -gpinfo.gothilo.min;
4091
4092 if (get_elf_backend_data (output_bfd)->want_got_sym)
4093 elf_hash_table (info)->hgot->root.u.def.value
4094 += bfinfdpic_got_initial_offset (info);
4095
4096 if (elf_hash_table (info)->dynamic_sections_created)
4097 bfinfdpic_plt_initial_offset (info) =
4098 bfinfdpic_plt_section (info)->size;
4099
4100 htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_assign_plt_entries,
4101 &gpinfo);
4102
4103 /* Allocate the PLT section contents only after
4104 _bfinfdpic_assign_plt_entries has a chance to add the size of the
4105 non-lazy PLT entries. */
4106 if (elf_hash_table (info)->dynamic_sections_created)
4107 {
4108 if (bfinfdpic_plt_section (info)->size == 0)
4109 bfinfdpic_plt_section (info)->flags |= SEC_EXCLUDE;
4110 else
4111 {
4112 bfinfdpic_plt_section (info)->contents =
4113 (bfd_byte *) bfd_zalloc (dynobj,
4114 bfinfdpic_plt_section (info)->size);
4115 if (bfinfdpic_plt_section (info)->contents == NULL)
4116 return FALSE;
4117 }
4118 }
4119
4120 if (elf_hash_table (info)->dynamic_sections_created)
4121 {
4122 if (bfinfdpic_got_section (info)->size)
4123 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0))
4124 return FALSE;
4125
4126 if (bfinfdpic_pltrel_section (info)->size)
4127 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
4128 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_REL)
4129 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
4130 return FALSE;
4131
4132 if (bfinfdpic_gotrel_section (info)->size)
4133 if (!_bfd_elf_add_dynamic_entry (info, DT_REL, 0)
4134 || !_bfd_elf_add_dynamic_entry (info, DT_RELSZ, 0)
4135 || !_bfd_elf_add_dynamic_entry (info, DT_RELENT,
4136 sizeof (Elf32_External_Rel)))
4137 return FALSE;
4138 }
4139
4140 return TRUE;
4141 }
4142
4143 static bfd_boolean
4144 elf32_bfinfdpic_always_size_sections (bfd *output_bfd,
4145 struct bfd_link_info *info)
4146 {
4147 if (!info->relocatable)
4148 {
4149 struct elf_link_hash_entry *h;
4150
4151 /* Force a PT_GNU_STACK segment to be created. */
4152 if (! elf_tdata (output_bfd)->stack_flags)
4153 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
4154
4155 /* Define __stacksize if it's not defined yet. */
4156 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
4157 FALSE, FALSE, FALSE);
4158 if (! h || h->root.type != bfd_link_hash_defined
4159 || h->type != STT_OBJECT
4160 || !h->def_regular)
4161 {
4162 struct bfd_link_hash_entry *bh = NULL;
4163
4164 if (!(_bfd_generic_link_add_one_symbol
4165 (info, output_bfd, "__stacksize",
4166 BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
4167 (const char *) NULL, FALSE,
4168 get_elf_backend_data (output_bfd)->collect, &bh)))
4169 return FALSE;
4170
4171 h = (struct elf_link_hash_entry *) bh;
4172 h->def_regular = 1;
4173 h->type = STT_OBJECT;
4174 }
4175 }
4176
4177 return TRUE;
4178 }
4179
4180 static bfd_boolean
4181 elf32_bfinfdpic_modify_program_headers (bfd *output_bfd,
4182 struct bfd_link_info *info)
4183 {
4184 struct elf_obj_tdata *tdata = elf_tdata (output_bfd);
4185 struct elf_segment_map *m;
4186 Elf_Internal_Phdr *p;
4187
4188 /* objcopy and strip preserve what's already there using
4189 elf32_bfinfdpic_copy_private_bfd_data (). */
4190 if (! info)
4191 return TRUE;
4192
4193 for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++)
4194 if (m->p_type == PT_GNU_STACK)
4195 break;
4196
4197 if (m)
4198 {
4199 struct elf_link_hash_entry *h;
4200
4201 /* Obtain the pointer to the __stacksize symbol. */
4202 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
4203 FALSE, FALSE, FALSE);
4204 if (h)
4205 {
4206 while (h->root.type == bfd_link_hash_indirect
4207 || h->root.type == bfd_link_hash_warning)
4208 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4209 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
4210 }
4211
4212 /* Set the header p_memsz from the symbol value. We
4213 intentionally ignore the symbol section. */
4214 if (h && h->root.type == bfd_link_hash_defined)
4215 p->p_memsz = h->root.u.def.value;
4216 else
4217 p->p_memsz = DEFAULT_STACK_SIZE;
4218
4219 p->p_align = 8;
4220 }
4221
4222 return TRUE;
4223 }
4224
4225 static bfd_boolean
4226 elf32_bfinfdpic_finish_dynamic_sections (bfd *output_bfd,
4227 struct bfd_link_info *info)
4228 {
4229 bfd *dynobj;
4230 asection *sdyn;
4231
4232 dynobj = elf_hash_table (info)->dynobj;
4233
4234 if (bfinfdpic_got_section (info))
4235 {
4236 BFD_ASSERT (bfinfdpic_gotrel_section (info)->size
4237 == (bfinfdpic_gotrel_section (info)->reloc_count
4238 * sizeof (Elf32_External_Rel)));
4239
4240 if (bfinfdpic_gotfixup_section (info))
4241 {
4242 struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
4243 bfd_vma got_value = hgot->root.u.def.value
4244 + hgot->root.u.def.section->output_section->vma
4245 + hgot->root.u.def.section->output_offset;
4246
4247 _bfinfdpic_add_rofixup (output_bfd, bfinfdpic_gotfixup_section (info),
4248 got_value, 0);
4249
4250 if (bfinfdpic_gotfixup_section (info)->size
4251 != (bfinfdpic_gotfixup_section (info)->reloc_count * 4))
4252 {
4253 (*_bfd_error_handler)
4254 ("LINKER BUG: .rofixup section size mismatch");
4255 return FALSE;
4256 }
4257 }
4258 }
4259 if (elf_hash_table (info)->dynamic_sections_created)
4260 {
4261 BFD_ASSERT (bfinfdpic_pltrel_section (info)->size
4262 == (bfinfdpic_pltrel_section (info)->reloc_count
4263 * sizeof (Elf32_External_Rel)));
4264 }
4265
4266 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4267
4268 if (elf_hash_table (info)->dynamic_sections_created)
4269 {
4270 Elf32_External_Dyn * dyncon;
4271 Elf32_External_Dyn * dynconend;
4272
4273 BFD_ASSERT (sdyn != NULL);
4274
4275 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4276 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4277
4278 for (; dyncon < dynconend; dyncon++)
4279 {
4280 Elf_Internal_Dyn dyn;
4281
4282 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4283
4284 switch (dyn.d_tag)
4285 {
4286 default:
4287 break;
4288
4289 case DT_PLTGOT:
4290 dyn.d_un.d_ptr = bfinfdpic_got_section (info)->output_section->vma
4291 + bfinfdpic_got_section (info)->output_offset
4292 + bfinfdpic_got_initial_offset (info);
4293 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4294 break;
4295
4296 case DT_JMPREL:
4297 dyn.d_un.d_ptr = bfinfdpic_pltrel_section (info)
4298 ->output_section->vma
4299 + bfinfdpic_pltrel_section (info)->output_offset;
4300 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4301 break;
4302
4303 case DT_PLTRELSZ:
4304 dyn.d_un.d_val = bfinfdpic_pltrel_section (info)->size;
4305 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4306 break;
4307 }
4308 }
4309 }
4310
4311 return TRUE;
4312 }
4313
4314 /* Adjust a symbol defined by a dynamic object and referenced by a
4315 regular object. */
4316
4317 static bfd_boolean
4318 elf32_bfinfdpic_adjust_dynamic_symbol
4319 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
4320 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4321 {
4322 bfd * dynobj;
4323
4324 dynobj = elf_hash_table (info)->dynobj;
4325
4326 /* Make sure we know what is going on here. */
4327 BFD_ASSERT (dynobj != NULL
4328 && (h->u.weakdef != NULL
4329 || (h->def_dynamic
4330 && h->ref_regular
4331 && !h->def_regular)));
4332
4333 /* If this is a weak symbol, and there is a real definition, the
4334 processor independent code will have arranged for us to see the
4335 real definition first, and we can just use the same value. */
4336 if (h->u.weakdef != NULL)
4337 {
4338 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4339 || h->u.weakdef->root.type == bfd_link_hash_defweak);
4340 h->root.u.def.section = h->u.weakdef->root.u.def.section;
4341 h->root.u.def.value = h->u.weakdef->root.u.def.value;
4342 }
4343
4344 return TRUE;
4345 }
4346
4347 /* Perform any actions needed for dynamic symbols. */
4348
4349 static bfd_boolean
4350 elf32_bfinfdpic_finish_dynamic_symbol
4351 (bfd *output_bfd ATTRIBUTE_UNUSED,
4352 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4353 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
4354 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
4355 {
4356 return TRUE;
4357 }
4358
4359 /* Decide whether to attempt to turn absptr or lsda encodings in
4360 shared libraries into pcrel within the given input section. */
4361
4362 static bfd_boolean
4363 bfinfdpic_elf_use_relative_eh_frame
4364 (bfd *input_bfd ATTRIBUTE_UNUSED,
4365 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4366 asection *eh_frame_section ATTRIBUTE_UNUSED)
4367 {
4368 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
4369 return FALSE;
4370 }
4371
4372 /* Adjust the contents of an eh_frame_hdr section before they're output. */
4373
4374 static bfd_byte
4375 bfinfdpic_elf_encode_eh_address (bfd *abfd,
4376 struct bfd_link_info *info,
4377 asection *osec, bfd_vma offset,
4378 asection *loc_sec, bfd_vma loc_offset,
4379 bfd_vma *encoded)
4380 {
4381 struct elf_link_hash_entry *h;
4382
4383 h = elf_hash_table (info)->hgot;
4384 BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
4385
4386 if (! h || (_bfinfdpic_osec_to_segment (abfd, osec)
4387 == _bfinfdpic_osec_to_segment (abfd, loc_sec->output_section)))
4388 return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
4389 loc_sec, loc_offset, encoded);
4390
4391 BFD_ASSERT (_bfinfdpic_osec_to_segment (abfd, osec)
4392 == (_bfinfdpic_osec_to_segment
4393 (abfd, h->root.u.def.section->output_section)));
4394
4395 *encoded = osec->vma + offset
4396 - (h->root.u.def.value
4397 + h->root.u.def.section->output_section->vma
4398 + h->root.u.def.section->output_offset);
4399
4400 return DW_EH_PE_datarel | DW_EH_PE_sdata4;
4401 }
4402
4403
4404
4405 /* Look through the relocs for a section during the first phase.
4406
4407 Besides handling virtual table relocs for gc, we have to deal with
4408 all sorts of PIC-related relocations. We describe below the
4409 general plan on how to handle such relocations, even though we only
4410 collect information at this point, storing them in hash tables for
4411 perusal of later passes.
4412
4413 32 relocations are propagated to the linker output when creating
4414 position-independent output. LO16 and HI16 relocations are not
4415 supposed to be encountered in this case.
4416
4417 LABEL16 should always be resolvable by the linker, since it's only
4418 used by branches.
4419
4420 LABEL24, on the other hand, is used by calls. If it turns out that
4421 the target of a call is a dynamic symbol, a PLT entry must be
4422 created for it, which triggers the creation of a private function
4423 descriptor and, unless lazy binding is disabled, a lazy PLT entry.
4424
4425 GPREL relocations require the referenced symbol to be in the same
4426 segment as _gp, but this can only be checked later.
4427
4428 All GOT, GOTOFF and FUNCDESC relocations require a .got section to
4429 exist. LABEL24 might as well, since it may require a PLT entry,
4430 that will require a got.
4431
4432 Non-FUNCDESC GOT relocations require a GOT entry to be created
4433 regardless of whether the symbol is dynamic. However, since a
4434 global symbol that turns out to not be exported may have the same
4435 address of a non-dynamic symbol, we don't assign GOT entries at
4436 this point, such that we can share them in this case. A relocation
4437 for the GOT entry always has to be created, be it to offset a
4438 private symbol by the section load address, be it to get the symbol
4439 resolved dynamically.
4440
4441 FUNCDESC GOT relocations require a GOT entry to be created, and
4442 handled as if a FUNCDESC relocation was applied to the GOT entry in
4443 an object file.
4444
4445 FUNCDESC relocations referencing a symbol that turns out to NOT be
4446 dynamic cause a private function descriptor to be created. The
4447 FUNCDESC relocation then decays to a 32 relocation that points at
4448 the private descriptor. If the symbol is dynamic, the FUNCDESC
4449 relocation is propagated to the linker output, such that the
4450 dynamic linker creates the canonical descriptor, pointing to the
4451 dynamically-resolved definition of the function.
4452
4453 Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
4454 symbols that are assigned to the same segment as the GOT, but we
4455 can only check this later, after we know the complete set of
4456 symbols defined and/or exported.
4457
4458 FUNCDESC GOTOFF relocations require a function descriptor to be
4459 created and, unless lazy binding is disabled or the symbol is not
4460 dynamic, a lazy PLT entry. Since we can't tell at this point
4461 whether a symbol is going to be dynamic, we have to decide later
4462 whether to create a lazy PLT entry or bind the descriptor directly
4463 to the private function.
4464
4465 FUNCDESC_VALUE relocations are not supposed to be present in object
4466 files, but they may very well be simply propagated to the linker
4467 output, since they have no side effect.
4468
4469
4470 A function descriptor always requires a FUNCDESC_VALUE relocation.
4471 Whether it's in .plt.rel or not depends on whether lazy binding is
4472 enabled and on whether the referenced symbol is dynamic.
4473
4474 The existence of a lazy PLT requires the resolverStub lazy PLT
4475 entry to be present.
4476
4477
4478 As for assignment of GOT, PLT and lazy PLT entries, and private
4479 descriptors, we might do them all sequentially, but we can do
4480 better than that. For example, we can place GOT entries and
4481 private function descriptors referenced using 12-bit operands
4482 closer to the PIC register value, such that these relocations don't
4483 overflow. Those that are only referenced with LO16 relocations
4484 could come next, but we may as well place PLT-required function
4485 descriptors in the 12-bit range to make them shorter. Symbols
4486 referenced with LO16/HI16 may come next, but we may place
4487 additional function descriptors in the 16-bit range if we can
4488 reliably tell that we've already placed entries that are ever
4489 referenced with only LO16. PLT entries are therefore generated as
4490 small as possible, while not introducing relocation overflows in
4491 GOT or FUNCDESC_GOTOFF relocations. Lazy PLT entries could be
4492 generated before or after PLT entries, but not intermingled with
4493 them, such that we can have more lazy PLT entries in range for a
4494 branch to the resolverStub. The resolverStub should be emitted at
4495 the most distant location from the first lazy PLT entry such that
4496 it's still in range for a branch, or closer, if there isn't a need
4497 for so many lazy PLT entries. Additional lazy PLT entries may be
4498 emitted after the resolverStub, as long as branches are still in
4499 range. If the branch goes out of range, longer lazy PLT entries
4500 are emitted.
4501
4502 We could further optimize PLT and lazy PLT entries by giving them
4503 priority in assignment to closer-to-gr17 locations depending on the
4504 number of occurrences of references to them (assuming a function
4505 that's called more often is more important for performance, so its
4506 PLT entry should be faster), or taking hints from the compiler.
4507 Given infinite time and money... :-) */
4508
4509 static bfd_boolean
4510 bfinfdpic_check_relocs (bfd *abfd, struct bfd_link_info *info,
4511 asection *sec, const Elf_Internal_Rela *relocs)
4512 {
4513 Elf_Internal_Shdr *symtab_hdr;
4514 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4515 const Elf_Internal_Rela *rel;
4516 const Elf_Internal_Rela *rel_end;
4517 bfd *dynobj;
4518 struct bfinfdpic_relocs_info *picrel;
4519
4520 if (info->relocatable)
4521 return TRUE;
4522
4523 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4524 sym_hashes = elf_sym_hashes (abfd);
4525 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
4526 if (!elf_bad_symtab (abfd))
4527 sym_hashes_end -= symtab_hdr->sh_info;
4528
4529 dynobj = elf_hash_table (info)->dynobj;
4530 rel_end = relocs + sec->reloc_count;
4531 for (rel = relocs; rel < rel_end; rel++)
4532 {
4533 struct elf_link_hash_entry *h;
4534 unsigned long r_symndx;
4535
4536 r_symndx = ELF32_R_SYM (rel->r_info);
4537 if (r_symndx < symtab_hdr->sh_info)
4538 h = NULL;
4539 else
4540 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4541
4542 switch (ELF32_R_TYPE (rel->r_info))
4543 {
4544 case R_BFIN_GOT17M4:
4545 case R_BFIN_GOTHI:
4546 case R_BFIN_GOTLO:
4547 case R_BFIN_FUNCDESC_GOT17M4:
4548 case R_BFIN_FUNCDESC_GOTHI:
4549 case R_BFIN_FUNCDESC_GOTLO:
4550 case R_BFIN_GOTOFF17M4:
4551 case R_BFIN_GOTOFFHI:
4552 case R_BFIN_GOTOFFLO:
4553 case R_BFIN_FUNCDESC_GOTOFF17M4:
4554 case R_BFIN_FUNCDESC_GOTOFFHI:
4555 case R_BFIN_FUNCDESC_GOTOFFLO:
4556 case R_BFIN_FUNCDESC:
4557 case R_BFIN_FUNCDESC_VALUE:
4558 if (! IS_FDPIC (abfd))
4559 goto bad_reloc;
4560 /* Fall through. */
4561 case R_pcrel24:
4562 case R_pcrel24_jump_l:
4563 case R_byte4_data:
4564 if (IS_FDPIC (abfd) && ! dynobj)
4565 {
4566 elf_hash_table (info)->dynobj = dynobj = abfd;
4567 if (! _bfin_create_got_section (abfd, info))
4568 return FALSE;
4569 }
4570 if (! IS_FDPIC (abfd))
4571 {
4572 picrel = NULL;
4573 break;
4574 }
4575 if (h != NULL)
4576 {
4577 if (h->dynindx == -1)
4578 switch (ELF_ST_VISIBILITY (h->other))
4579 {
4580 case STV_INTERNAL:
4581 case STV_HIDDEN:
4582 break;
4583 default:
4584 bfd_elf_link_record_dynamic_symbol (info, h);
4585 break;
4586 }
4587 picrel
4588 = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info),
4589 abfd, h,
4590 rel->r_addend, INSERT);
4591 }
4592 else
4593 picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
4594 (info), abfd, r_symndx,
4595 rel->r_addend, INSERT);
4596 if (! picrel)
4597 return FALSE;
4598 break;
4599
4600 default:
4601 picrel = NULL;
4602 break;
4603 }
4604
4605 switch (ELF32_R_TYPE (rel->r_info))
4606 {
4607 case R_pcrel24:
4608 case R_pcrel24_jump_l:
4609 if (IS_FDPIC (abfd))
4610 picrel->call = 1;
4611 break;
4612
4613 case R_BFIN_FUNCDESC_VALUE:
4614 picrel->relocsfdv++;
4615 if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
4616 picrel->relocs32--;
4617 /* Fall through. */
4618
4619 case R_byte4_data:
4620 if (! IS_FDPIC (abfd))
4621 break;
4622
4623 picrel->sym = 1;
4624 if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
4625 picrel->relocs32++;
4626 break;
4627
4628 case R_BFIN_GOT17M4:
4629 picrel->got17m4 = 1;
4630 break;
4631
4632 case R_BFIN_GOTHI:
4633 case R_BFIN_GOTLO:
4634 picrel->gothilo = 1;
4635 break;
4636
4637 case R_BFIN_FUNCDESC_GOT17M4:
4638 picrel->fdgot17m4 = 1;
4639 break;
4640
4641 case R_BFIN_FUNCDESC_GOTHI:
4642 case R_BFIN_FUNCDESC_GOTLO:
4643 picrel->fdgothilo = 1;
4644 break;
4645
4646 case R_BFIN_GOTOFF17M4:
4647 case R_BFIN_GOTOFFHI:
4648 case R_BFIN_GOTOFFLO:
4649 picrel->gotoff = 1;
4650 break;
4651
4652 case R_BFIN_FUNCDESC_GOTOFF17M4:
4653 picrel->fdgoff17m4 = 1;
4654 break;
4655
4656 case R_BFIN_FUNCDESC_GOTOFFHI:
4657 case R_BFIN_FUNCDESC_GOTOFFLO:
4658 picrel->fdgoffhilo = 1;
4659 break;
4660
4661 case R_BFIN_FUNCDESC:
4662 picrel->fd = 1;
4663 picrel->relocsfd++;
4664 break;
4665
4666 /* This relocation describes the C++ object vtable hierarchy.
4667 Reconstruct it for later use during GC. */
4668 case R_BFIN_GNU_VTINHERIT:
4669 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4670 return FALSE;
4671 break;
4672
4673 /* This relocation describes which C++ vtable entries are actually
4674 used. Record for later use during GC. */
4675 case R_BFIN_GNU_VTENTRY:
4676 BFD_ASSERT (h != NULL);
4677 if (h != NULL
4678 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4679 return FALSE;
4680 break;
4681
4682 case R_huimm16:
4683 case R_luimm16:
4684 case R_pcrel12_jump_s:
4685 case R_pcrel10:
4686 break;
4687
4688 default:
4689 bad_reloc:
4690 (*_bfd_error_handler)
4691 (_("%B: unsupported relocation type %i"),
4692 abfd, ELF32_R_TYPE (rel->r_info));
4693 return FALSE;
4694 }
4695 }
4696
4697 return TRUE;
4698 }
4699
4700 /* Set the right machine number for a Blackfin ELF file. */
4701
4702 static bfd_boolean
4703 elf32_bfin_object_p (bfd *abfd)
4704 {
4705 bfd_default_set_arch_mach (abfd, bfd_arch_bfin, 0);
4706 return (((elf_elfheader (abfd)->e_flags & EF_BFIN_FDPIC) != 0)
4707 == (IS_FDPIC (abfd)));
4708 }
4709
4710 static bfd_boolean
4711 elf32_bfin_set_private_flags (bfd * abfd, flagword flags)
4712 {
4713 elf_elfheader (abfd)->e_flags = flags;
4714 elf_flags_init (abfd) = TRUE;
4715 return TRUE;
4716 }
4717
4718 /* Copy backend specific data from one object module to another. */
4719
4720 static bfd_boolean
4721 bfin_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4722 {
4723 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4724 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4725 return TRUE;
4726
4727 BFD_ASSERT (!elf_flags_init (obfd)
4728 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
4729
4730 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
4731 elf_flags_init (obfd) = TRUE;
4732
4733 /* Copy object attributes. */
4734 _bfd_elf_copy_obj_attributes (ibfd, obfd);
4735
4736 return TRUE;
4737 }
4738
4739 static bfd_boolean
4740 elf32_bfinfdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4741 {
4742 unsigned i;
4743
4744 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4745 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4746 return TRUE;
4747
4748 if (! bfin_elf_copy_private_bfd_data (ibfd, obfd))
4749 return FALSE;
4750
4751 if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
4752 || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
4753 return TRUE;
4754
4755 /* Copy the stack size. */
4756 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
4757 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
4758 {
4759 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
4760
4761 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
4762 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
4763 {
4764 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
4765
4766 /* Rewrite the phdrs, since we're only called after they
4767 were first written. */
4768 if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
4769 ->s->sizeof_ehdr, SEEK_SET) != 0
4770 || get_elf_backend_data (obfd)->s
4771 ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
4772 elf_elfheader (obfd)->e_phnum) != 0)
4773 return FALSE;
4774 break;
4775 }
4776
4777 break;
4778 }
4779
4780 return TRUE;
4781 }
4782
4783
4784 /* Display the flags field. */
4785 static bfd_boolean
4786 elf32_bfin_print_private_bfd_data (bfd * abfd, PTR ptr)
4787 {
4788 FILE *file = (FILE *) ptr;
4789 flagword flags;
4790
4791 BFD_ASSERT (abfd != NULL && ptr != NULL);
4792
4793 /* Print normal ELF private data. */
4794 _bfd_elf_print_private_bfd_data (abfd, ptr);
4795
4796 flags = elf_elfheader (abfd)->e_flags;
4797
4798 /* xgettext:c-format */
4799 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
4800
4801 if (flags & EF_BFIN_PIC)
4802 fprintf (file, " -fpic");
4803
4804 if (flags & EF_BFIN_FDPIC)
4805 fprintf (file, " -mfdpic");
4806
4807 fputc ('\n', file);
4808
4809 return TRUE;
4810 }
4811
4812 /* Merge backend specific data from an object file to the output
4813 object file when linking. */
4814
4815 static bfd_boolean
4816 elf32_bfin_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4817 {
4818 flagword old_flags, old_partial;
4819 flagword new_flags, new_partial;
4820 bfd_boolean error = FALSE;
4821
4822 new_flags = elf_elfheader (ibfd)->e_flags;
4823 old_flags = elf_elfheader (obfd)->e_flags;
4824
4825 if (new_flags & EF_BFIN_FDPIC)
4826 new_flags &= ~EF_BFIN_PIC;
4827
4828 #ifdef DEBUG
4829 (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
4830 old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
4831 bfd_get_filename (ibfd));
4832 #endif
4833
4834 if (!elf_flags_init (obfd)) /* First call, no flags set. */
4835 {
4836 elf_flags_init (obfd) = TRUE;
4837 old_flags = new_flags;
4838 }
4839
4840 else if (new_flags == old_flags) /* Compatible flags are ok. */
4841 ;
4842
4843 else /* Possibly incompatible flags. */
4844 {
4845 /* We don't have to do anything if the pic flags are the same, or the new
4846 module(s) were compiled with -mlibrary-pic. */
4847 new_partial = (new_flags & EF_BFIN_PIC_FLAGS);
4848 old_partial = (old_flags & EF_BFIN_PIC_FLAGS);
4849 if (new_partial == old_partial)
4850 ;
4851
4852 /* If we have mixtures of -fpic and -fPIC, or in both bits. */
4853 else if (new_partial != 0 && old_partial != 0)
4854 old_flags |= new_partial;
4855
4856 /* One module was compiled for pic and the other was not, see if we have
4857 had any relocations that are not pic-safe. */
4858 else
4859 old_flags |= new_partial;
4860
4861 }
4862
4863 /* Update the old flags now with changes made above. */
4864 elf_elfheader (obfd)->e_flags = old_flags;
4865
4866 if (((new_flags & EF_BFIN_FDPIC) == 0)
4867 != (! IS_FDPIC (ibfd)))
4868 {
4869 error = TRUE;
4870 if (IS_FDPIC (obfd))
4871 (*_bfd_error_handler)
4872 (_("%s: cannot link non-fdpic object file into fdpic executable"),
4873 bfd_get_filename (ibfd));
4874 else
4875 (*_bfd_error_handler)
4876 (_("%s: cannot link fdpic object file into non-fdpic executable"),
4877 bfd_get_filename (ibfd));
4878 }
4879
4880 if (error)
4881 bfd_set_error (bfd_error_bad_value);
4882
4883 return !error;
4884 }
4885 \f
4886 /* bfin ELF linker hash entry. */
4887
4888 struct bfin_link_hash_entry
4889 {
4890 struct elf_link_hash_entry root;
4891
4892 /* Number of PC relative relocs copied for this symbol. */
4893 struct bfin_pcrel_relocs_copied *pcrel_relocs_copied;
4894 };
4895
4896 /* bfin ELF linker hash table. */
4897
4898 struct bfin_link_hash_table
4899 {
4900 struct elf_link_hash_table root;
4901
4902 /* Small local sym to section mapping cache. */
4903 struct sym_sec_cache sym_sec;
4904 };
4905
4906 #define bfin_hash_entry(ent) ((struct bfin_link_hash_entry *) (ent))
4907
4908 static struct bfd_hash_entry *
4909 bfin_link_hash_newfunc (struct bfd_hash_entry *entry,
4910 struct bfd_hash_table *table, const char *string)
4911 {
4912 struct bfd_hash_entry *ret = entry;
4913
4914 /* Allocate the structure if it has not already been allocated by a
4915 subclass. */
4916 if (ret == NULL)
4917 ret = bfd_hash_allocate (table, sizeof (struct bfin_link_hash_entry));
4918 if (ret == NULL)
4919 return ret;
4920
4921 /* Call the allocation method of the superclass. */
4922 ret = _bfd_elf_link_hash_newfunc (ret, table, string);
4923 if (ret != NULL)
4924 bfin_hash_entry (ret)->pcrel_relocs_copied = NULL;
4925
4926 return ret;
4927 }
4928
4929 /* Create an bfin ELF linker hash table. */
4930
4931 static struct bfd_link_hash_table *
4932 bfin_link_hash_table_create (bfd * abfd)
4933 {
4934 struct bfin_link_hash_table *ret;
4935 bfd_size_type amt = sizeof (struct bfin_link_hash_table);
4936
4937 ret = bfd_zalloc (abfd, amt);
4938 if (ret == NULL)
4939 return NULL;
4940
4941 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
4942 bfin_link_hash_newfunc,
4943 sizeof (struct elf_link_hash_entry)))
4944 {
4945 free (ret);
4946 return NULL;
4947 }
4948
4949 ret->sym_sec.abfd = NULL;
4950
4951 return &ret->root.root;
4952 }
4953
4954 /* The size in bytes of an entry in the procedure linkage table. */
4955
4956 /* Finish up the dynamic sections. */
4957
4958 static bfd_boolean
4959 bfin_finish_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
4960 struct bfd_link_info *info)
4961 {
4962 bfd *dynobj;
4963 asection *sdyn;
4964
4965 dynobj = elf_hash_table (info)->dynobj;
4966
4967 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4968
4969 if (elf_hash_table (info)->dynamic_sections_created)
4970 {
4971 Elf32_External_Dyn *dyncon, *dynconend;
4972
4973 BFD_ASSERT (sdyn != NULL);
4974
4975 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4976 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4977 for (; dyncon < dynconend; dyncon++)
4978 {
4979 Elf_Internal_Dyn dyn;
4980
4981 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4982
4983 }
4984
4985 }
4986 return TRUE;
4987 }
4988
4989 /* Finish up dynamic symbol handling. We set the contents of various
4990 dynamic sections here. */
4991
4992 static bfd_boolean
4993 bfin_finish_dynamic_symbol (bfd * output_bfd,
4994 struct bfd_link_info *info,
4995 struct elf_link_hash_entry *h,
4996 Elf_Internal_Sym * sym)
4997 {
4998 bfd *dynobj;
4999
5000 dynobj = elf_hash_table (info)->dynobj;
5001
5002 if (h->got.offset != (bfd_vma) - 1)
5003 {
5004 asection *sgot;
5005 asection *srela;
5006 Elf_Internal_Rela rela;
5007 bfd_byte *loc;
5008
5009 /* This symbol has an entry in the global offset table.
5010 Set it up. */
5011
5012 sgot = bfd_get_section_by_name (dynobj, ".got");
5013 srela = bfd_get_section_by_name (dynobj, ".rela.got");
5014 BFD_ASSERT (sgot != NULL && srela != NULL);
5015
5016 rela.r_offset = (sgot->output_section->vma
5017 + sgot->output_offset
5018 + (h->got.offset & ~(bfd_vma) 1));
5019
5020 /* If this is a -Bsymbolic link, and the symbol is defined
5021 locally, we just want to emit a RELATIVE reloc. Likewise if
5022 the symbol was forced to be local because of a version file.
5023 The entry in the global offset table will already have been
5024 initialized in the relocate_section function. */
5025 if (info->shared
5026 && (info->symbolic
5027 || h->dynindx == -1 || h->forced_local) && h->def_regular)
5028 {
5029 fprintf(stderr, "*** check this relocation %s\n", __FUNCTION__);
5030 rela.r_info = ELF32_R_INFO (0, R_pcrel24);
5031 rela.r_addend = bfd_get_signed_32 (output_bfd,
5032 (sgot->contents
5033 +
5034 (h->got.
5035 offset & ~(bfd_vma) 1)));
5036 }
5037 else
5038 {
5039 bfd_put_32 (output_bfd, (bfd_vma) 0,
5040 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
5041 rela.r_info = ELF32_R_INFO (h->dynindx, R_got);
5042 rela.r_addend = 0;
5043 }
5044
5045 loc = srela->contents;
5046 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
5047 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5048 }
5049
5050 if (h->needs_copy)
5051 {
5052 BFD_ASSERT (0);
5053 }
5054 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
5055 if (strcmp (h->root.root.string, "__DYNAMIC") == 0
5056 || h == elf_hash_table (info)->hgot)
5057 sym->st_shndx = SHN_ABS;
5058
5059 return TRUE;
5060 }
5061
5062 /* Adjust a symbol defined by a dynamic object and referenced by a
5063 regular object. The current definition is in some section of the
5064 dynamic object, but we're not including those sections. We have to
5065 change the definition to something the rest of the link can
5066 understand. */
5067
5068 static bfd_boolean
5069 bfin_adjust_dynamic_symbol (struct bfd_link_info *info,
5070 struct elf_link_hash_entry *h)
5071 {
5072 bfd *dynobj;
5073 asection *s;
5074 unsigned int power_of_two;
5075
5076 dynobj = elf_hash_table (info)->dynobj;
5077
5078 /* Make sure we know what is going on here. */
5079 BFD_ASSERT (dynobj != NULL
5080 && (h->needs_plt
5081 || h->u.weakdef != NULL
5082 || (h->def_dynamic && h->ref_regular && !h->def_regular)));
5083
5084 /* If this is a function, put it in the procedure linkage table. We
5085 will fill in the contents of the procedure linkage table later,
5086 when we know the address of the .got section. */
5087 if (h->type == STT_FUNC || h->needs_plt)
5088 {
5089 BFD_ASSERT(0);
5090 }
5091
5092 /* If this is a weak symbol, and there is a real definition, the
5093 processor independent code will have arranged for us to see the
5094 real definition first, and we can just use the same value. */
5095 if (h->u.weakdef != NULL)
5096 {
5097 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5098 || h->u.weakdef->root.type == bfd_link_hash_defweak);
5099 h->root.u.def.section = h->u.weakdef->root.u.def.section;
5100 h->root.u.def.value = h->u.weakdef->root.u.def.value;
5101 return TRUE;
5102 }
5103
5104 /* This is a reference to a symbol defined by a dynamic object which
5105 is not a function. */
5106
5107 /* If we are creating a shared library, we must presume that the
5108 only references to the symbol are via the global offset table.
5109 For such cases we need not do anything here; the relocations will
5110 be handled correctly by relocate_section. */
5111 if (info->shared)
5112 return TRUE;
5113
5114 /* We must allocate the symbol in our .dynbss section, which will
5115 become part of the .bss section of the executable. There will be
5116 an entry for this symbol in the .dynsym section. The dynamic
5117 object will contain position independent code, so all references
5118 from the dynamic object to this symbol will go through the global
5119 offset table. The dynamic linker will use the .dynsym entry to
5120 determine the address it must put in the global offset table, so
5121 both the dynamic object and the regular object will refer to the
5122 same memory location for the variable. */
5123
5124 s = bfd_get_section_by_name (dynobj, ".dynbss");
5125 BFD_ASSERT (s != NULL);
5126
5127 /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
5128 copy the initial value out of the dynamic object and into the
5129 runtime process image. We need to remember the offset into the
5130 .rela.bss section we are going to use. */
5131 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5132 {
5133 asection *srel;
5134
5135 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
5136 BFD_ASSERT (srel != NULL);
5137 srel->size += sizeof (Elf32_External_Rela);
5138 h->needs_copy = 1;
5139 }
5140
5141 /* We need to figure out the alignment required for this symbol. I
5142 have no idea how ELF linkers handle this. */
5143 power_of_two = bfd_log2 (h->size);
5144 if (power_of_two > 3)
5145 power_of_two = 3;
5146
5147 /* Apply the required alignment. */
5148 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
5149 if (power_of_two > bfd_get_section_alignment (dynobj, s))
5150 {
5151 if (!bfd_set_section_alignment (dynobj, s, power_of_two))
5152 return FALSE;
5153 }
5154
5155 /* Define the symbol as being at this point in the section. */
5156 h->root.u.def.section = s;
5157 h->root.u.def.value = s->size;
5158
5159 /* Increment the section size to make room for the symbol. */
5160 s->size += h->size;
5161
5162 return TRUE;
5163 }
5164
5165 /* The bfin linker needs to keep track of the number of relocs that it
5166 decides to copy in check_relocs for each symbol. This is so that it
5167 can discard PC relative relocs if it doesn't need them when linking
5168 with -Bsymbolic. We store the information in a field extending the
5169 regular ELF linker hash table. */
5170
5171 /* This structure keeps track of the number of PC relative relocs we have
5172 copied for a given symbol. */
5173
5174 struct bfin_pcrel_relocs_copied
5175 {
5176 /* Next section. */
5177 struct bfin_pcrel_relocs_copied *next;
5178 /* A section in dynobj. */
5179 asection *section;
5180 /* Number of relocs copied in this section. */
5181 bfd_size_type count;
5182 };
5183
5184 /* This function is called via elf_link_hash_traverse if we are
5185 creating a shared object. In the -Bsymbolic case it discards the
5186 space allocated to copy PC relative relocs against symbols which
5187 are defined in regular objects. For the normal shared case, it
5188 discards space for pc-relative relocs that have become local due to
5189 symbol visibility changes. We allocated space for them in the
5190 check_relocs routine, but we won't fill them in in the
5191 relocate_section routine.
5192
5193 We also check whether any of the remaining relocations apply
5194 against a readonly section, and set the DF_TEXTREL flag in this
5195 case. */
5196
5197 static bfd_boolean
5198 bfin_discard_copies (struct elf_link_hash_entry *h, PTR inf)
5199 {
5200 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5201 struct bfin_pcrel_relocs_copied *s;
5202
5203 if (h->root.type == bfd_link_hash_warning)
5204 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5205
5206 if (!h->def_regular || (!info->symbolic && !h->forced_local))
5207 {
5208 if ((info->flags & DF_TEXTREL) == 0)
5209 {
5210 /* Look for relocations against read-only sections. */
5211 for (s = bfin_hash_entry (h)->pcrel_relocs_copied;
5212 s != NULL; s = s->next)
5213 if ((s->section->flags & SEC_READONLY) != 0)
5214 {
5215 info->flags |= DF_TEXTREL;
5216 break;
5217 }
5218 }
5219
5220 return TRUE;
5221 }
5222
5223 for (s = bfin_hash_entry (h)->pcrel_relocs_copied;
5224 s != NULL; s = s->next)
5225 s->section->size -= s->count * sizeof (Elf32_External_Rela);
5226
5227 return TRUE;
5228 }
5229
5230 static bfd_boolean
5231 bfin_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
5232 struct bfd_link_info *info)
5233 {
5234 bfd *dynobj;
5235 asection *s;
5236 bfd_boolean relocs;
5237
5238 dynobj = elf_hash_table (info)->dynobj;
5239 BFD_ASSERT (dynobj != NULL);
5240
5241 if (elf_hash_table (info)->dynamic_sections_created)
5242 {
5243 /* Set the contents of the .interp section to the interpreter. */
5244 if (info->executable)
5245 {
5246 s = bfd_get_section_by_name (dynobj, ".interp");
5247 BFD_ASSERT (s != NULL);
5248 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5249 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5250 }
5251 }
5252 else
5253 {
5254 /* We may have created entries in the .rela.got section.
5255 However, if we are not creating the dynamic sections, we will
5256 not actually use these entries. Reset the size of .rela.got,
5257 which will cause it to get stripped from the output file
5258 below. */
5259 s = bfd_get_section_by_name (dynobj, ".rela.got");
5260 if (s != NULL)
5261 s->size = 0;
5262 }
5263
5264 /* If this is a -Bsymbolic shared link, then we need to discard all
5265 PC relative relocs against symbols defined in a regular object.
5266 For the normal shared case we discard the PC relative relocs
5267 against symbols that have become local due to visibility changes.
5268 We allocated space for them in the check_relocs routine, but we
5269 will not fill them in in the relocate_section routine. */
5270 if (info->shared)
5271 elf_link_hash_traverse (elf_hash_table (info),
5272 bfin_discard_copies, (PTR) info);
5273
5274 /* The check_relocs and adjust_dynamic_symbol entry points have
5275 determined the sizes of the various dynamic sections. Allocate
5276 memory for them. */
5277 relocs = FALSE;
5278 for (s = dynobj->sections; s != NULL; s = s->next)
5279 {
5280 const char *name;
5281 bfd_boolean strip;
5282
5283 if ((s->flags & SEC_LINKER_CREATED) == 0)
5284 continue;
5285
5286 /* It's OK to base decisions on the section name, because none
5287 of the dynobj section names depend upon the input files. */
5288 name = bfd_get_section_name (dynobj, s);
5289
5290 strip = FALSE;
5291
5292 if (CONST_STRNEQ (name, ".rela"))
5293 {
5294 if (s->size == 0)
5295 {
5296 /* If we don't need this section, strip it from the
5297 output file. This is mostly to handle .rela.bss and
5298 .rela.plt. We must create both sections in
5299 create_dynamic_sections, because they must be created
5300 before the linker maps input sections to output
5301 sections. The linker does that before
5302 adjust_dynamic_symbol is called, and it is that
5303 function which decides whether anything needs to go
5304 into these sections. */
5305 strip = TRUE;
5306 }
5307 else
5308 {
5309 relocs = TRUE;
5310
5311 /* We use the reloc_count field as a counter if we need
5312 to copy relocs into the output file. */
5313 s->reloc_count = 0;
5314 }
5315 }
5316 else if (! CONST_STRNEQ (name, ".got"))
5317 {
5318 /* It's not one of our sections, so don't allocate space. */
5319 continue;
5320 }
5321
5322 if (strip)
5323 {
5324 s->flags |= SEC_EXCLUDE;
5325 continue;
5326 }
5327
5328 /* Allocate memory for the section contents. */
5329 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
5330 Unused entries should be reclaimed before the section's contents
5331 are written out, but at the moment this does not happen. Thus in
5332 order to prevent writing out garbage, we initialise the section's
5333 contents to zero. */
5334 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
5335 if (s->contents == NULL && s->size != 0)
5336 return FALSE;
5337 }
5338
5339 if (elf_hash_table (info)->dynamic_sections_created)
5340 {
5341 /* Add some entries to the .dynamic section. We fill in the
5342 values later, in bfin_finish_dynamic_sections, but we
5343 must add the entries now so that we get the correct size for
5344 the .dynamic section. The DT_DEBUG entry is filled in by the
5345 dynamic linker and used by the debugger. */
5346 #define add_dynamic_entry(TAG, VAL) \
5347 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5348
5349 if (!info->shared)
5350 {
5351 if (!add_dynamic_entry (DT_DEBUG, 0))
5352 return FALSE;
5353 }
5354
5355
5356 if (relocs)
5357 {
5358 if (!add_dynamic_entry (DT_RELA, 0)
5359 || !add_dynamic_entry (DT_RELASZ, 0)
5360 || !add_dynamic_entry (DT_RELAENT,
5361 sizeof (Elf32_External_Rela)))
5362 return FALSE;
5363 }
5364
5365 if ((info->flags & DF_TEXTREL) != 0)
5366 {
5367 if (!add_dynamic_entry (DT_TEXTREL, 0))
5368 return FALSE;
5369 }
5370 }
5371 #undef add_dynamic_entry
5372
5373 return TRUE;
5374 }
5375 \f
5376 /* Given a .data section and a .emreloc in-memory section, store
5377 relocation information into the .emreloc section which can be
5378 used at runtime to relocate the section. This is called by the
5379 linker when the --embedded-relocs switch is used. This is called
5380 after the add_symbols entry point has been called for all the
5381 objects, and before the final_link entry point is called. */
5382
5383 bfd_boolean bfd_bfin_elf32_create_embedded_relocs
5384 PARAMS ((bfd *, struct bfd_link_info *, asection *, asection *, char **));
5385
5386 bfd_boolean
5387 bfd_bfin_elf32_create_embedded_relocs (
5388 bfd *abfd,
5389 struct bfd_link_info *info,
5390 asection *datasec,
5391 asection *relsec,
5392 char **errmsg)
5393 {
5394 Elf_Internal_Shdr *symtab_hdr;
5395 Elf_Internal_Sym *isymbuf = NULL;
5396 Elf_Internal_Rela *internal_relocs = NULL;
5397 Elf_Internal_Rela *irel, *irelend;
5398 bfd_byte *p;
5399 bfd_size_type amt;
5400
5401 BFD_ASSERT (! info->relocatable);
5402
5403 *errmsg = NULL;
5404
5405 if (datasec->reloc_count == 0)
5406 return TRUE;
5407
5408 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5409
5410 /* Get a copy of the native relocations. */
5411 internal_relocs = (_bfd_elf_link_read_relocs
5412 (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
5413 info->keep_memory));
5414 if (internal_relocs == NULL)
5415 goto error_return;
5416
5417 amt = (bfd_size_type) datasec->reloc_count * 12;
5418 relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
5419 if (relsec->contents == NULL)
5420 goto error_return;
5421
5422 p = relsec->contents;
5423
5424 irelend = internal_relocs + datasec->reloc_count;
5425 for (irel = internal_relocs; irel < irelend; irel++, p += 12)
5426 {
5427 asection *targetsec;
5428
5429 /* We are going to write a four byte longword into the runtime
5430 reloc section. The longword will be the address in the data
5431 section which must be relocated. It is followed by the name
5432 of the target section NUL-padded or truncated to 8
5433 characters. */
5434
5435 /* We can only relocate absolute longword relocs at run time. */
5436 if (ELF32_R_TYPE (irel->r_info) != (int) R_byte4_data)
5437 {
5438 *errmsg = _("unsupported reloc type");
5439 bfd_set_error (bfd_error_bad_value);
5440 goto error_return;
5441 }
5442
5443 /* Get the target section referred to by the reloc. */
5444 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
5445 {
5446 /* A local symbol. */
5447 Elf_Internal_Sym *isym;
5448
5449 /* Read this BFD's local symbols if we haven't done so already. */
5450 if (isymbuf == NULL)
5451 {
5452 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5453 if (isymbuf == NULL)
5454 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
5455 symtab_hdr->sh_info, 0,
5456 NULL, NULL, NULL);
5457 if (isymbuf == NULL)
5458 goto error_return;
5459 }
5460
5461 isym = isymbuf + ELF32_R_SYM (irel->r_info);
5462 targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
5463 }
5464 else
5465 {
5466 unsigned long indx;
5467 struct elf_link_hash_entry *h;
5468
5469 /* An external symbol. */
5470 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
5471 h = elf_sym_hashes (abfd)[indx];
5472 BFD_ASSERT (h != NULL);
5473 if (h->root.type == bfd_link_hash_defined
5474 || h->root.type == bfd_link_hash_defweak)
5475 targetsec = h->root.u.def.section;
5476 else
5477 targetsec = NULL;
5478 }
5479
5480 bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
5481 memset (p + 4, 0, 8);
5482 if (targetsec != NULL)
5483 strncpy ((char *) p + 4, targetsec->output_section->name, 8);
5484 }
5485
5486 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
5487 free (isymbuf);
5488 if (internal_relocs != NULL
5489 && elf_section_data (datasec)->relocs != internal_relocs)
5490 free (internal_relocs);
5491 return TRUE;
5492
5493 error_return:
5494 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
5495 free (isymbuf);
5496 if (internal_relocs != NULL
5497 && elf_section_data (datasec)->relocs != internal_relocs)
5498 free (internal_relocs);
5499 return FALSE;
5500 }
5501 \f
5502 #define TARGET_LITTLE_SYM bfd_elf32_bfin_vec
5503 #define TARGET_LITTLE_NAME "elf32-bfin"
5504 #define ELF_ARCH bfd_arch_bfin
5505 #define ELF_MACHINE_CODE EM_BLACKFIN
5506 #define ELF_MAXPAGESIZE 0x1000
5507 #define elf_symbol_leading_char '_'
5508
5509 #define bfd_elf32_bfd_reloc_type_lookup bfin_bfd_reloc_type_lookup
5510 #define bfd_elf32_bfd_reloc_name_lookup \
5511 bfin_bfd_reloc_name_lookup
5512 #define elf_info_to_howto bfin_info_to_howto
5513 #define elf_info_to_howto_rel 0
5514 #define elf_backend_object_p elf32_bfin_object_p
5515
5516 #define bfd_elf32_bfd_is_local_label_name \
5517 bfin_is_local_label_name
5518 #define bfin_hash_table(p) \
5519 ((struct bfin_link_hash_table *) (p)->hash)
5520
5521
5522
5523 #define elf_backend_create_dynamic_sections \
5524 _bfd_elf_create_dynamic_sections
5525 #define bfd_elf32_bfd_link_hash_table_create \
5526 bfin_link_hash_table_create
5527 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link
5528
5529 #define elf_backend_check_relocs bfin_check_relocs
5530 #define elf_backend_adjust_dynamic_symbol \
5531 bfin_adjust_dynamic_symbol
5532 #define elf_backend_size_dynamic_sections \
5533 bfin_size_dynamic_sections
5534 #define elf_backend_relocate_section bfin_relocate_section
5535 #define elf_backend_finish_dynamic_symbol \
5536 bfin_finish_dynamic_symbol
5537 #define elf_backend_finish_dynamic_sections \
5538 bfin_finish_dynamic_sections
5539 #define elf_backend_gc_mark_hook bfin_gc_mark_hook
5540 #define elf_backend_gc_sweep_hook bfin_gc_sweep_hook
5541 #define bfd_elf32_bfd_merge_private_bfd_data \
5542 elf32_bfin_merge_private_bfd_data
5543 #define bfd_elf32_bfd_set_private_flags \
5544 elf32_bfin_set_private_flags
5545 #define bfd_elf32_bfd_print_private_bfd_data \
5546 elf32_bfin_print_private_bfd_data
5547 #define elf_backend_reloc_type_class elf32_bfin_reloc_type_class
5548 #define elf_backend_can_gc_sections 1
5549 #define elf_backend_can_refcount 1
5550 #define elf_backend_want_got_plt 0
5551 #define elf_backend_plt_readonly 1
5552 #define elf_backend_want_plt_sym 0
5553 #define elf_backend_got_header_size 12
5554 #define elf_backend_rela_normal 1
5555
5556 #include "elf32-target.h"
5557
5558 #undef TARGET_LITTLE_SYM
5559 #define TARGET_LITTLE_SYM bfd_elf32_bfinfdpic_vec
5560 #undef TARGET_LITTLE_NAME
5561 #define TARGET_LITTLE_NAME "elf32-bfinfdpic"
5562 #undef elf32_bed
5563 #define elf32_bed elf32_bfinfdpic_bed
5564
5565 #undef elf_backend_gc_sweep_hook
5566
5567 #undef elf_backend_got_header_size
5568 #define elf_backend_got_header_size 0
5569
5570 #undef elf_backend_relocate_section
5571 #define elf_backend_relocate_section bfinfdpic_relocate_section
5572 #undef elf_backend_check_relocs
5573 #define elf_backend_check_relocs bfinfdpic_check_relocs
5574
5575 #undef bfd_elf32_bfd_link_hash_table_create
5576 #define bfd_elf32_bfd_link_hash_table_create \
5577 bfinfdpic_elf_link_hash_table_create
5578 #undef elf_backend_always_size_sections
5579 #define elf_backend_always_size_sections \
5580 elf32_bfinfdpic_always_size_sections
5581 #undef elf_backend_modify_program_headers
5582 #define elf_backend_modify_program_headers \
5583 elf32_bfinfdpic_modify_program_headers
5584 #undef bfd_elf32_bfd_copy_private_bfd_data
5585 #define bfd_elf32_bfd_copy_private_bfd_data \
5586 elf32_bfinfdpic_copy_private_bfd_data
5587
5588 #undef elf_backend_create_dynamic_sections
5589 #define elf_backend_create_dynamic_sections \
5590 elf32_bfinfdpic_create_dynamic_sections
5591 #undef elf_backend_adjust_dynamic_symbol
5592 #define elf_backend_adjust_dynamic_symbol \
5593 elf32_bfinfdpic_adjust_dynamic_symbol
5594 #undef elf_backend_size_dynamic_sections
5595 #define elf_backend_size_dynamic_sections \
5596 elf32_bfinfdpic_size_dynamic_sections
5597 #undef elf_backend_finish_dynamic_symbol
5598 #define elf_backend_finish_dynamic_symbol \
5599 elf32_bfinfdpic_finish_dynamic_symbol
5600 #undef elf_backend_finish_dynamic_sections
5601 #define elf_backend_finish_dynamic_sections \
5602 elf32_bfinfdpic_finish_dynamic_sections
5603
5604 #undef elf_backend_can_make_relative_eh_frame
5605 #define elf_backend_can_make_relative_eh_frame \
5606 bfinfdpic_elf_use_relative_eh_frame
5607 #undef elf_backend_can_make_lsda_relative_eh_frame
5608 #define elf_backend_can_make_lsda_relative_eh_frame \
5609 bfinfdpic_elf_use_relative_eh_frame
5610 #undef elf_backend_encode_eh_address
5611 #define elf_backend_encode_eh_address \
5612 bfinfdpic_elf_encode_eh_address
5613
5614 #undef elf_backend_may_use_rel_p
5615 #define elf_backend_may_use_rel_p 1
5616 #undef elf_backend_may_use_rela_p
5617 #define elf_backend_may_use_rela_p 1
5618 /* We use REL for dynamic relocations only. */
5619 #undef elf_backend_default_use_rela_p
5620 #define elf_backend_default_use_rela_p 1
5621
5622 #undef elf_backend_omit_section_dynsym
5623 #define elf_backend_omit_section_dynsym _bfinfdpic_link_omit_section_dynsym
5624
5625 #include "elf32-target.h"
git-cvsimport of binutils cvsroot