projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
bfd/
[deliverable/binutils-gdb.git] / bfd / elf32-bfin.c
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 2 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, MA 02110-1301,
19 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_GOT12", /* 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 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1983 return FALSE;
1984 break;
1985
1986 case R_got:
1987 if (h != NULL
1988 && strcmp (h->root.root.string, "__GLOBAL_OFFSET_TABLE_") == 0)
1989 break;
1990 /* Fall through. */
1991
1992 if (dynobj == NULL)
1993 {
1994 /* Create the .got section. */
1995 elf_hash_table (info)->dynobj = dynobj = abfd;
1996 if (!_bfd_elf_create_got_section (dynobj, info))
1997 return FALSE;
1998 }
1999
2000 if (sgot == NULL)
2001 {
2002 sgot = bfd_get_section_by_name (dynobj, ".got");
2003 BFD_ASSERT (sgot != NULL);
2004 }
2005
2006 if (srelgot == NULL && (h != NULL || info->shared))
2007 {
2008 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2009 if (srelgot == NULL)
2010 {
2011 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
2012 | SEC_IN_MEMORY | SEC_LINKER_CREATED
2013 | SEC_READONLY);
2014 srelgot = bfd_make_section_with_flags (dynobj, ".rela.got",
2015 flags);
2016 if (srelgot == NULL
2017 || !bfd_set_section_alignment (dynobj, srelgot, 2))
2018 return FALSE;
2019 }
2020 }
2021
2022 if (h != NULL)
2023 {
2024 if (h->got.refcount == 0)
2025 {
2026 /* Make sure this symbol is output as a dynamic symbol. */
2027 if (h->dynindx == -1 && !h->forced_local)
2028 {
2029 if (!bfd_elf_link_record_dynamic_symbol (info, h))
2030 return FALSE;
2031 }
2032
2033 /* Allocate space in the .got section. */
2034 sgot->size += 4;
2035 /* Allocate relocation space. */
2036 srelgot->size += sizeof (Elf32_External_Rela);
2037 }
2038 h->got.refcount++;
2039 }
2040 else
2041 {
2042 /* This is a global offset table entry for a local symbol. */
2043 if (local_got_refcounts == NULL)
2044 {
2045 bfd_size_type size;
2046
2047 size = symtab_hdr->sh_info;
2048 size *= sizeof (bfd_signed_vma);
2049 local_got_refcounts = ((bfd_signed_vma *)
2050 bfd_zalloc (abfd, size));
2051 if (local_got_refcounts == NULL)
2052 return FALSE;
2053 elf_local_got_refcounts (abfd) = local_got_refcounts;
2054 }
2055 if (local_got_refcounts[r_symndx] == 0)
2056 {
2057 sgot->size += 4;
2058 if (info->shared)
2059 {
2060 /* If we are generating a shared object, we need to
2061 output a R_68K_RELATIVE reloc so that the dynamic
2062 linker can adjust this GOT entry. */
2063 srelgot->size += sizeof (Elf32_External_Rela);
2064 }
2065 }
2066 local_got_refcounts[r_symndx]++;
2067 }
2068 break;
2069
2070 default:
2071 break;
2072 }
2073 }
2074
2075 return TRUE;
2076 }
2077
2078 static enum elf_reloc_type_class
2079 elf32_bfin_reloc_type_class (const Elf_Internal_Rela * rela)
2080 {
2081 switch ((int) ELF32_R_TYPE (rela->r_info))
2082 {
2083 default:
2084 return reloc_class_normal;
2085 }
2086 }
2087 \f
2088 /* Relocate an Blackfin ELF section.
2089
2090 The RELOCATE_SECTION function is called by the new ELF backend linker
2091 to handle the relocations for a section.
2092
2093 The relocs are always passed as Rela structures; if the section
2094 actually uses Rel structures, the r_addend field will always be
2095 zero.
2096
2097 This function is responsible for adjusting the section contents as
2098 necessary, and (if using Rela relocs and generating a relocatable
2099 output file) adjusting the reloc addend as necessary.
2100
2101 This function does not have to worry about setting the reloc
2102 address or the reloc symbol index.
2103
2104 LOCAL_SYMS is a pointer to the swapped in local symbols.
2105
2106 LOCAL_SECTIONS is an array giving the section in the input file
2107 corresponding to the st_shndx field of each local symbol.
2108
2109 The global hash table entry for the global symbols can be found
2110 via elf_sym_hashes (input_bfd).
2111
2112 When generating relocatable output, this function must handle
2113 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
2114 going to be the section symbol corresponding to the output
2115 section, which means that the addend must be adjusted
2116 accordingly. */
2117
2118 static bfd_boolean
2119 bfinfdpic_relocate_section (bfd * output_bfd,
2120 struct bfd_link_info *info,
2121 bfd * input_bfd,
2122 asection * input_section,
2123 bfd_byte * contents,
2124 Elf_Internal_Rela * relocs,
2125 Elf_Internal_Sym * local_syms,
2126 asection ** local_sections)
2127 {
2128 Elf_Internal_Shdr *symtab_hdr;
2129 struct elf_link_hash_entry **sym_hashes;
2130 Elf_Internal_Rela *rel;
2131 Elf_Internal_Rela *relend;
2132 unsigned isec_segment, got_segment, plt_segment,
2133 check_segment[2];
2134 int silence_segment_error = !(info->shared || info->pie);
2135
2136 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2137 sym_hashes = elf_sym_hashes (input_bfd);
2138 relend = relocs + input_section->reloc_count;
2139
2140 isec_segment = _bfinfdpic_osec_to_segment (output_bfd,
2141 input_section->output_section);
2142 if (IS_FDPIC (output_bfd) && bfinfdpic_got_section (info))
2143 got_segment = _bfinfdpic_osec_to_segment (output_bfd,
2144 bfinfdpic_got_section (info)
2145 ->output_section);
2146 else
2147 got_segment = -1;
2148 if (IS_FDPIC (output_bfd) && elf_hash_table (info)->dynamic_sections_created)
2149 plt_segment = _bfinfdpic_osec_to_segment (output_bfd,
2150 bfinfdpic_plt_section (info)
2151 ->output_section);
2152 else
2153 plt_segment = -1;
2154
2155 for (rel = relocs; rel < relend; rel ++)
2156 {
2157 reloc_howto_type *howto;
2158 unsigned long r_symndx;
2159 Elf_Internal_Sym *sym;
2160 asection *sec;
2161 struct elf_link_hash_entry *h;
2162 bfd_vma relocation;
2163 bfd_reloc_status_type r;
2164 const char * name = NULL;
2165 int r_type;
2166 asection *osec;
2167 struct bfinfdpic_relocs_info *picrel;
2168 bfd_vma orig_addend = rel->r_addend;
2169
2170 r_type = ELF32_R_TYPE (rel->r_info);
2171
2172 if (r_type == R_BFIN_GNU_VTINHERIT
2173 || r_type == R_BFIN_GNU_VTENTRY)
2174 continue;
2175
2176 r_symndx = ELF32_R_SYM (rel->r_info);
2177 howto = bfin_reloc_type_lookup (input_bfd, r_type);
2178 if (howto == NULL)
2179 {
2180 bfd_set_error (bfd_error_bad_value);
2181 return FALSE;
2182 }
2183
2184 h = NULL;
2185 sym = NULL;
2186 sec = NULL;
2187
2188 if (r_symndx < symtab_hdr->sh_info)
2189 {
2190 sym = local_syms + r_symndx;
2191 osec = sec = local_sections [r_symndx];
2192 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2193
2194 name = bfd_elf_string_from_elf_section
2195 (input_bfd, symtab_hdr->sh_link, sym->st_name);
2196 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
2197 }
2198 else
2199 {
2200 bfd_boolean warned;
2201 bfd_boolean unresolved_reloc;
2202
2203 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2204 r_symndx, symtab_hdr, sym_hashes,
2205 h, sec, relocation,
2206 unresolved_reloc, warned);
2207 osec = sec;
2208 }
2209
2210 if (sec != NULL && elf_discarded_section (sec))
2211 {
2212 /* For relocs against symbols from removed linkonce sections,
2213 or sections discarded by a linker script, we just want the
2214 section contents zeroed. Avoid any special processing. */
2215 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2216 rel->r_info = 0;
2217 rel->r_addend = 0;
2218 continue;
2219 }
2220
2221 if (info->relocatable)
2222 continue;
2223
2224 if (h != NULL
2225 && (h->root.type == bfd_link_hash_defined
2226 || h->root.type == bfd_link_hash_defweak)
2227 && !BFINFDPIC_SYM_LOCAL (info, h))
2228 {
2229 osec = sec = NULL;
2230 relocation = 0;
2231 }
2232
2233 switch (r_type)
2234 {
2235 case R_pcrel24:
2236 case R_pcrel24_jump_l:
2237 case R_byte4_data:
2238 if (! IS_FDPIC (output_bfd))
2239 goto non_fdpic;
2240
2241 case R_BFIN_GOT17M4:
2242 case R_BFIN_GOTHI:
2243 case R_BFIN_GOTLO:
2244 case R_BFIN_FUNCDESC_GOT17M4:
2245 case R_BFIN_FUNCDESC_GOTHI:
2246 case R_BFIN_FUNCDESC_GOTLO:
2247 case R_BFIN_GOTOFF17M4:
2248 case R_BFIN_GOTOFFHI:
2249 case R_BFIN_GOTOFFLO:
2250 case R_BFIN_FUNCDESC_GOTOFF17M4:
2251 case R_BFIN_FUNCDESC_GOTOFFHI:
2252 case R_BFIN_FUNCDESC_GOTOFFLO:
2253 case R_BFIN_FUNCDESC:
2254 case R_BFIN_FUNCDESC_VALUE:
2255 if (h != NULL)
2256 picrel = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info
2257 (info), input_bfd, h,
2258 orig_addend, INSERT);
2259 else
2260 /* In order to find the entry we created before, we must
2261 use the original addend, not the one that may have been
2262 modified by _bfd_elf_rela_local_sym(). */
2263 picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
2264 (info), input_bfd, r_symndx,
2265 orig_addend, INSERT);
2266 if (! picrel)
2267 return FALSE;
2268
2269 if (!_bfinfdpic_emit_got_relocs_plt_entries (picrel, output_bfd, info,
2270 osec, sym,
2271 rel->r_addend))
2272 {
2273 (*_bfd_error_handler)
2274 (_("%B: relocation at `%A+0x%x' references symbol `%s' with nonzero addend"),
2275 input_bfd, input_section, rel->r_offset, name);
2276 return FALSE;
2277
2278 }
2279
2280 break;
2281
2282 default:
2283 non_fdpic:
2284 picrel = NULL;
2285 if (h && ! BFINFDPIC_SYM_LOCAL (info, h))
2286 {
2287 info->callbacks->warning
2288 (info, _("relocation references symbol not defined in the module"),
2289 name, input_bfd, input_section, rel->r_offset);
2290 return FALSE;
2291 }
2292 break;
2293 }
2294
2295 switch (r_type)
2296 {
2297 case R_pcrel24:
2298 case R_pcrel24_jump_l:
2299 check_segment[0] = isec_segment;
2300 if (! IS_FDPIC (output_bfd))
2301 check_segment[1] = isec_segment;
2302 else if (picrel->plt)
2303 {
2304 relocation = bfinfdpic_plt_section (info)->output_section->vma
2305 + bfinfdpic_plt_section (info)->output_offset
2306 + picrel->plt_entry;
2307 check_segment[1] = plt_segment;
2308 }
2309 /* We don't want to warn on calls to undefined weak symbols,
2310 as calls to them must be protected by non-NULL tests
2311 anyway, and unprotected calls would invoke undefined
2312 behavior. */
2313 else if (picrel->symndx == -1
2314 && picrel->d.h->root.type == bfd_link_hash_undefweak)
2315 check_segment[1] = check_segment[0];
2316 else
2317 check_segment[1] = sec
2318 ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section)
2319 : (unsigned)-1;
2320 break;
2321
2322 case R_BFIN_GOT17M4:
2323 case R_BFIN_GOTHI:
2324 case R_BFIN_GOTLO:
2325 relocation = picrel->got_entry;
2326 check_segment[0] = check_segment[1] = got_segment;
2327 break;
2328
2329 case R_BFIN_FUNCDESC_GOT17M4:
2330 case R_BFIN_FUNCDESC_GOTHI:
2331 case R_BFIN_FUNCDESC_GOTLO:
2332 relocation = picrel->fdgot_entry;
2333 check_segment[0] = check_segment[1] = got_segment;
2334 break;
2335
2336 case R_BFIN_GOTOFFHI:
2337 case R_BFIN_GOTOFF17M4:
2338 case R_BFIN_GOTOFFLO:
2339 relocation -= bfinfdpic_got_section (info)->output_section->vma
2340 + bfinfdpic_got_section (info)->output_offset
2341 + bfinfdpic_got_initial_offset (info);
2342 check_segment[0] = got_segment;
2343 check_segment[1] = sec
2344 ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section)
2345 : (unsigned)-1;
2346 break;
2347
2348 case R_BFIN_FUNCDESC_GOTOFF17M4:
2349 case R_BFIN_FUNCDESC_GOTOFFHI:
2350 case R_BFIN_FUNCDESC_GOTOFFLO:
2351 relocation = picrel->fd_entry;
2352 check_segment[0] = check_segment[1] = got_segment;
2353 break;
2354
2355 case R_BFIN_FUNCDESC:
2356 {
2357 int dynindx;
2358 bfd_vma addend = rel->r_addend;
2359
2360 if (! (h && h->root.type == bfd_link_hash_undefweak
2361 && BFINFDPIC_SYM_LOCAL (info, h)))
2362 {
2363 /* If the symbol is dynamic and there may be dynamic
2364 symbol resolution because we are or are linked with a
2365 shared library, emit a FUNCDESC relocation such that
2366 the dynamic linker will allocate the function
2367 descriptor. If the symbol needs a non-local function
2368 descriptor but binds locally (e.g., its visibility is
2369 protected, emit a dynamic relocation decayed to
2370 section+offset. */
2371 if (h && ! BFINFDPIC_FUNCDESC_LOCAL (info, h)
2372 && BFINFDPIC_SYM_LOCAL (info, h)
2373 && !(info->executable && !info->pie))
2374 {
2375 dynindx = elf_section_data (h->root.u.def.section
2376 ->output_section)->dynindx;
2377 addend += h->root.u.def.section->output_offset
2378 + h->root.u.def.value;
2379 }
2380 else if (h && ! BFINFDPIC_FUNCDESC_LOCAL (info, h))
2381 {
2382 if (addend)
2383 {
2384 info->callbacks->warning
2385 (info, _("R_BFIN_FUNCDESC references dynamic symbol with nonzero addend"),
2386 name, input_bfd, input_section, rel->r_offset);
2387 return FALSE;
2388 }
2389 dynindx = h->dynindx;
2390 }
2391 else
2392 {
2393 /* Otherwise, we know we have a private function
2394 descriptor, so reference it directly. */
2395 BFD_ASSERT (picrel->privfd);
2396 r_type = R_byte4_data;
2397 dynindx = elf_section_data (bfinfdpic_got_section (info)
2398 ->output_section)->dynindx;
2399 addend = bfinfdpic_got_section (info)->output_offset
2400 + bfinfdpic_got_initial_offset (info)
2401 + picrel->fd_entry;
2402 }
2403
2404 /* If there is room for dynamic symbol resolution, emit
2405 the dynamic relocation. However, if we're linking an
2406 executable at a fixed location, we won't have emitted a
2407 dynamic symbol entry for the got section, so idx will
2408 be zero, which means we can and should compute the
2409 address of the private descriptor ourselves. */
2410 if (info->executable && !info->pie
2411 && (!h || BFINFDPIC_FUNCDESC_LOCAL (info, h)))
2412 {
2413 addend += bfinfdpic_got_section (info)->output_section->vma;
2414 if ((bfd_get_section_flags (output_bfd,
2415 input_section->output_section)
2416 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2417 {
2418 if (_bfinfdpic_osec_readonly_p (output_bfd,
2419 input_section
2420 ->output_section))
2421 {
2422 info->callbacks->warning
2423 (info,
2424 _("cannot emit fixups in read-only section"),
2425 name, input_bfd, input_section, rel->r_offset);
2426 return FALSE;
2427 }
2428 _bfinfdpic_add_rofixup (output_bfd,
2429 bfinfdpic_gotfixup_section
2430 (info),
2431 _bfd_elf_section_offset
2432 (output_bfd, info,
2433 input_section, rel->r_offset)
2434 + input_section
2435 ->output_section->vma
2436 + input_section->output_offset,
2437 picrel);
2438 }
2439 }
2440 else if ((bfd_get_section_flags (output_bfd,
2441 input_section->output_section)
2442 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2443 {
2444 bfd_vma offset;
2445
2446 if (_bfinfdpic_osec_readonly_p (output_bfd,
2447 input_section
2448 ->output_section))
2449 {
2450 info->callbacks->warning
2451 (info,
2452 _("cannot emit dynamic relocations in read-only section"),
2453 name, input_bfd, input_section, rel->r_offset);
2454 return FALSE;
2455 }
2456 offset = _bfd_elf_section_offset (output_bfd, info,
2457 input_section, rel->r_offset);
2458 /* Only output a reloc for a not deleted entry. */
2459 if (offset >= (bfd_vma) -2)
2460 _bfinfdpic_add_dyn_reloc (output_bfd,
2461 bfinfdpic_gotrel_section (info),
2462 0,
2463 R_unused0,
2464 dynindx, addend, picrel);
2465 else
2466 _bfinfdpic_add_dyn_reloc (output_bfd,
2467 bfinfdpic_gotrel_section (info),
2468 offset + input_section
2469 ->output_section->vma
2470 + input_section->output_offset,
2471 r_type,
2472 dynindx, addend, picrel);
2473 }
2474 else
2475 addend += bfinfdpic_got_section (info)->output_section->vma;
2476 }
2477
2478 /* We want the addend in-place because dynamic
2479 relocations are REL. Setting relocation to it should
2480 arrange for it to be installed. */
2481 relocation = addend - rel->r_addend;
2482 }
2483 check_segment[0] = check_segment[1] = got_segment;
2484 break;
2485
2486 case R_byte4_data:
2487 if (! IS_FDPIC (output_bfd))
2488 {
2489 check_segment[0] = check_segment[1] = -1;
2490 break;
2491 }
2492 /* Fall through. */
2493 case R_BFIN_FUNCDESC_VALUE:
2494 {
2495 int dynindx;
2496 bfd_vma addend = rel->r_addend;
2497
2498 /* If the symbol is dynamic but binds locally, use
2499 section+offset. */
2500 if (h && ! BFINFDPIC_SYM_LOCAL (info, h))
2501 {
2502 if (addend && r_type == R_BFIN_FUNCDESC_VALUE)
2503 {
2504 info->callbacks->warning
2505 (info, _("R_BFIN_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
2506 name, input_bfd, input_section, rel->r_offset);
2507 return FALSE;
2508 }
2509 dynindx = h->dynindx;
2510 }
2511 else
2512 {
2513 if (h)
2514 addend += h->root.u.def.value;
2515 else
2516 addend += sym->st_value;
2517 if (osec)
2518 addend += osec->output_offset;
2519 if (osec && osec->output_section
2520 && ! bfd_is_abs_section (osec->output_section)
2521 && ! bfd_is_und_section (osec->output_section))
2522 dynindx = elf_section_data (osec->output_section)->dynindx;
2523 else
2524 dynindx = 0;
2525 }
2526
2527 /* If we're linking an executable at a fixed address, we
2528 can omit the dynamic relocation as long as the symbol
2529 is defined in the current link unit (which is implied
2530 by its output section not being NULL). */
2531 if (info->executable && !info->pie
2532 && (!h || BFINFDPIC_SYM_LOCAL (info, h)))
2533 {
2534 if (osec)
2535 addend += osec->output_section->vma;
2536 if (IS_FDPIC (input_bfd)
2537 && (bfd_get_section_flags (output_bfd,
2538 input_section->output_section)
2539 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2540 {
2541 if (_bfinfdpic_osec_readonly_p (output_bfd,
2542 input_section
2543 ->output_section))
2544 {
2545 info->callbacks->warning
2546 (info,
2547 _("cannot emit fixups in read-only section"),
2548 name, input_bfd, input_section, rel->r_offset);
2549 return FALSE;
2550 }
2551 if (!h || h->root.type != bfd_link_hash_undefweak)
2552 {
2553 _bfinfdpic_add_rofixup (output_bfd,
2554 bfinfdpic_gotfixup_section
2555 (info),
2556 _bfd_elf_section_offset
2557 (output_bfd, info,
2558 input_section, rel->r_offset)
2559 + input_section
2560 ->output_section->vma
2561 + input_section->output_offset,
2562 picrel);
2563 if (r_type == R_BFIN_FUNCDESC_VALUE)
2564 _bfinfdpic_add_rofixup
2565 (output_bfd,
2566 bfinfdpic_gotfixup_section (info),
2567 _bfd_elf_section_offset
2568 (output_bfd, info,
2569 input_section, rel->r_offset)
2570 + input_section->output_section->vma
2571 + input_section->output_offset + 4, picrel);
2572 }
2573 }
2574 }
2575 else
2576 {
2577 if ((bfd_get_section_flags (output_bfd,
2578 input_section->output_section)
2579 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2580 {
2581 if (_bfinfdpic_osec_readonly_p (output_bfd,
2582 input_section
2583 ->output_section))
2584 {
2585 info->callbacks->warning
2586 (info,
2587 _("cannot emit dynamic relocations in read-only section"),
2588 name, input_bfd, input_section, rel->r_offset);
2589 return FALSE;
2590 }
2591 _bfinfdpic_add_dyn_reloc (output_bfd,
2592 bfinfdpic_gotrel_section (info),
2593 _bfd_elf_section_offset
2594 (output_bfd, info,
2595 input_section, rel->r_offset)
2596 + input_section
2597 ->output_section->vma
2598 + input_section->output_offset,
2599 r_type, dynindx, addend, picrel);
2600 }
2601 else if (osec)
2602 addend += osec->output_section->vma;
2603 /* We want the addend in-place because dynamic
2604 relocations are REL. Setting relocation to it
2605 should arrange for it to be installed. */
2606 relocation = addend - rel->r_addend;
2607 }
2608
2609 if (r_type == R_BFIN_FUNCDESC_VALUE)
2610 {
2611 /* If we've omitted the dynamic relocation, just emit
2612 the fixed addresses of the symbol and of the local
2613 GOT base offset. */
2614 if (info->executable && !info->pie
2615 && (!h || BFINFDPIC_SYM_LOCAL (info, h)))
2616 bfd_put_32 (output_bfd,
2617 bfinfdpic_got_section (info)->output_section->vma
2618 + bfinfdpic_got_section (info)->output_offset
2619 + bfinfdpic_got_initial_offset (info),
2620 contents + rel->r_offset + 4);
2621 else
2622 /* A function descriptor used for lazy or local
2623 resolving is initialized such that its high word
2624 contains the output section index in which the
2625 PLT entries are located, and the low word
2626 contains the offset of the lazy PLT entry entry
2627 point into that section. */
2628 bfd_put_32 (output_bfd,
2629 h && ! BFINFDPIC_SYM_LOCAL (info, h)
2630 ? 0
2631 : _bfinfdpic_osec_to_segment (output_bfd,
2632 sec
2633 ->output_section),
2634 contents + rel->r_offset + 4);
2635 }
2636 }
2637 check_segment[0] = check_segment[1] = got_segment;
2638 break;
2639
2640 default:
2641 check_segment[0] = isec_segment;
2642 check_segment[1] = sec
2643 ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section)
2644 : (unsigned)-1;
2645 break;
2646 }
2647
2648 if (check_segment[0] != check_segment[1] && IS_FDPIC (output_bfd))
2649 {
2650 #if 1 /* If you take this out, remove the #error from fdpic-static-6.d
2651 in the ld testsuite. */
2652 /* This helps catch problems in GCC while we can't do more
2653 than static linking. The idea is to test whether the
2654 input file basename is crt0.o only once. */
2655 if (silence_segment_error == 1)
2656 silence_segment_error =
2657 (strlen (input_bfd->filename) == 6
2658 && strcmp (input_bfd->filename, "crt0.o") == 0)
2659 || (strlen (input_bfd->filename) > 6
2660 && strcmp (input_bfd->filename
2661 + strlen (input_bfd->filename) - 7,
2662 "/crt0.o") == 0)
2663 ? -1 : 0;
2664 #endif
2665 if (!silence_segment_error
2666 /* We don't want duplicate errors for undefined
2667 symbols. */
2668 && !(picrel && picrel->symndx == -1
2669 && picrel->d.h->root.type == bfd_link_hash_undefined))
2670 info->callbacks->warning
2671 (info,
2672 (info->shared || info->pie)
2673 ? _("relocations between different segments are not supported")
2674 : _("warning: relocation references a different segment"),
2675 name, input_bfd, input_section, rel->r_offset);
2676 if (!silence_segment_error && (info->shared || info->pie))
2677 return FALSE;
2678 elf_elfheader (output_bfd)->e_flags |= EF_BFIN_PIC;
2679 }
2680
2681 switch (r_type)
2682 {
2683 case R_BFIN_GOTOFFHI:
2684 /* We need the addend to be applied before we shift the
2685 value right. */
2686 relocation += rel->r_addend;
2687 /* Fall through. */
2688 case R_BFIN_GOTHI:
2689 case R_BFIN_FUNCDESC_GOTHI:
2690 case R_BFIN_FUNCDESC_GOTOFFHI:
2691 relocation >>= 16;
2692 /* Fall through. */
2693
2694 case R_BFIN_GOTLO:
2695 case R_BFIN_FUNCDESC_GOTLO:
2696 case R_BFIN_GOTOFFLO:
2697 case R_BFIN_FUNCDESC_GOTOFFLO:
2698 relocation &= 0xffff;
2699 break;
2700
2701 default:
2702 break;
2703 }
2704
2705 switch (r_type)
2706 {
2707 case R_pcrel24:
2708 case R_pcrel24_jump_l:
2709 if (! IS_FDPIC (output_bfd) || ! picrel->plt)
2710 break;
2711 /* Fall through. */
2712
2713 /* When referencing a GOT entry, a function descriptor or a
2714 PLT, we don't want the addend to apply to the reference,
2715 but rather to the referenced symbol. The actual entry
2716 will have already been created taking the addend into
2717 account, so cancel it out here. */
2718 case R_BFIN_GOT17M4:
2719 case R_BFIN_GOTHI:
2720 case R_BFIN_GOTLO:
2721 case R_BFIN_FUNCDESC_GOT17M4:
2722 case R_BFIN_FUNCDESC_GOTHI:
2723 case R_BFIN_FUNCDESC_GOTLO:
2724 case R_BFIN_FUNCDESC_GOTOFF17M4:
2725 case R_BFIN_FUNCDESC_GOTOFFHI:
2726 case R_BFIN_FUNCDESC_GOTOFFLO:
2727 /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF17M4
2728 here, since we do want to apply the addend to the others.
2729 Note that we've applied the addend to GOTOFFHI before we
2730 shifted it right. */
2731 case R_BFIN_GOTOFFHI:
2732 relocation -= rel->r_addend;
2733 break;
2734
2735 default:
2736 break;
2737 }
2738
2739 if (r_type == R_pcrel24
2740 || r_type == R_pcrel24_jump_l)
2741 {
2742 bfd_vma x;
2743 bfd_vma address = rel->r_offset;
2744
2745 relocation += rel->r_addend;
2746
2747 /* Perform usual pc-relative correction. */
2748 relocation -= input_section->output_section->vma + input_section->output_offset;
2749 relocation -= address;
2750
2751 /* We are getting reloc_entry->address 2 byte off from
2752 the start of instruction. Assuming absolute postion
2753 of the reloc data. But, following code had been written assuming
2754 reloc address is starting at begining of instruction.
2755 To compensate that I have increased the value of
2756 relocation by 1 (effectively 2) and used the addr -2 instead of addr. */
2757
2758 relocation += 2;
2759 address -= 2;
2760
2761 relocation >>= 1;
2762
2763 x = bfd_get_16 (input_bfd, contents + address);
2764 x = (x & 0xff00) | ((relocation >> 16) & 0xff);
2765 bfd_put_16 (input_bfd, x, contents + address);
2766
2767 x = bfd_get_16 (input_bfd, contents + address + 2);
2768 x = relocation & 0xFFFF;
2769 bfd_put_16 (input_bfd, x, contents + address + 2);
2770 r = bfd_reloc_ok;
2771 }
2772 else
2773 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2774 contents, rel->r_offset,
2775 relocation, rel->r_addend);
2776
2777 if (r != bfd_reloc_ok)
2778 {
2779 const char * msg = (const char *) NULL;
2780
2781 switch (r)
2782 {
2783 case bfd_reloc_overflow:
2784 r = info->callbacks->reloc_overflow
2785 (info, (h ? &h->root : NULL), name, howto->name,
2786 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2787 break;
2788
2789 case bfd_reloc_undefined:
2790 r = info->callbacks->undefined_symbol
2791 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
2792 break;
2793
2794 case bfd_reloc_outofrange:
2795 msg = _("internal error: out of range error");
2796 break;
2797
2798 case bfd_reloc_notsupported:
2799 msg = _("internal error: unsupported relocation error");
2800 break;
2801
2802 case bfd_reloc_dangerous:
2803 msg = _("internal error: dangerous relocation");
2804 break;
2805
2806 default:
2807 msg = _("internal error: unknown error");
2808 break;
2809 }
2810
2811 if (msg)
2812 r = info->callbacks->warning
2813 (info, msg, name, input_bfd, input_section, rel->r_offset);
2814
2815 if (! r)
2816 return FALSE;
2817 }
2818 }
2819
2820 return TRUE;
2821 }
2822
2823 static bfd_boolean
2824 bfin_relocate_section (bfd * output_bfd,
2825 struct bfd_link_info *info,
2826 bfd * input_bfd,
2827 asection * input_section,
2828 bfd_byte * contents,
2829 Elf_Internal_Rela * relocs,
2830 Elf_Internal_Sym * local_syms,
2831 asection ** local_sections)
2832 {
2833 bfd *dynobj;
2834 Elf_Internal_Shdr *symtab_hdr;
2835 struct elf_link_hash_entry **sym_hashes;
2836 bfd_vma *local_got_offsets;
2837 asection *sgot;
2838 asection *sreloc;
2839 Elf_Internal_Rela *rel;
2840 Elf_Internal_Rela *relend;
2841 int i = 0;
2842
2843 dynobj = elf_hash_table (info)->dynobj;
2844 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2845 sym_hashes = elf_sym_hashes (input_bfd);
2846 local_got_offsets = elf_local_got_offsets (input_bfd);
2847
2848 sgot = NULL;
2849 sreloc = NULL;
2850
2851 rel = relocs;
2852 relend = relocs + input_section->reloc_count;
2853 for (; rel < relend; rel++, i++)
2854 {
2855 int r_type;
2856 reloc_howto_type *howto;
2857 unsigned long r_symndx;
2858 struct elf_link_hash_entry *h;
2859 Elf_Internal_Sym *sym;
2860 asection *sec;
2861 bfd_vma relocation = 0;
2862 bfd_boolean unresolved_reloc;
2863 bfd_reloc_status_type r;
2864 bfd_vma address;
2865
2866 r_type = ELF32_R_TYPE (rel->r_info);
2867 if (r_type < 0 || r_type >= 243)
2868 {
2869 bfd_set_error (bfd_error_bad_value);
2870 return FALSE;
2871 }
2872
2873 if (r_type == R_BFIN_GNU_VTENTRY
2874 || r_type == R_BFIN_GNU_VTINHERIT)
2875 continue;
2876
2877 howto = bfin_reloc_type_lookup (input_bfd, r_type);
2878 if (howto == NULL)
2879 {
2880 bfd_set_error (bfd_error_bad_value);
2881 return FALSE;
2882 }
2883 r_symndx = ELF32_R_SYM (rel->r_info);
2884
2885 h = NULL;
2886 sym = NULL;
2887 sec = NULL;
2888 unresolved_reloc = FALSE;
2889
2890 if (r_symndx < symtab_hdr->sh_info)
2891 {
2892 sym = local_syms + r_symndx;
2893 sec = local_sections[r_symndx];
2894 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2895 }
2896 else
2897 {
2898 bfd_boolean warned;
2899
2900 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2901 r_symndx, symtab_hdr, sym_hashes,
2902 h, sec, relocation,
2903 unresolved_reloc, warned);
2904 }
2905
2906 if (sec != NULL && elf_discarded_section (sec))
2907 {
2908 /* For relocs against symbols from removed linkonce sections,
2909 or sections discarded by a linker script, we just want the
2910 section contents zeroed. Avoid any special processing. */
2911 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2912 rel->r_info = 0;
2913 rel->r_addend = 0;
2914 continue;
2915 }
2916
2917 if (info->relocatable)
2918 continue;
2919
2920 address = rel->r_offset;
2921
2922 /* Then, process normally. */
2923 switch (r_type)
2924 {
2925 case R_BFIN_GNU_VTINHERIT:
2926 case R_BFIN_GNU_VTENTRY:
2927 return bfd_reloc_ok;
2928
2929 case R_got:
2930 /* Relocation is to the address of the entry for this symbol
2931 in the global offset table. */
2932 if (h != NULL
2933 && strcmp (h->root.root.string, "__GLOBAL_OFFSET_TABLE_") == 0)
2934 goto do_default;
2935 /* Fall through. */
2936 /* Relocation is the offset of the entry for this symbol in
2937 the global offset table. */
2938
2939 {
2940 bfd_vma off;
2941
2942 if (sgot == NULL)
2943 {
2944 sgot = bfd_get_section_by_name (dynobj, ".got");
2945 BFD_ASSERT (sgot != NULL);
2946 }
2947
2948 if (h != NULL)
2949 {
2950 bfd_boolean dyn;
2951
2952 off = h->got.offset;
2953 BFD_ASSERT (off != (bfd_vma) - 1);
2954 dyn = elf_hash_table (info)->dynamic_sections_created;
2955
2956 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2957 || (info->shared
2958 && (info->symbolic
2959 || h->dynindx == -1
2960 || h->forced_local)
2961 && h->def_regular))
2962 {
2963 /* This is actually a static link, or it is a
2964 -Bsymbolic link and the symbol is defined
2965 locally, or the symbol was forced to be local
2966 because of a version file.. We must initialize
2967 this entry in the global offset table. Since
2968 the offset must always be a multiple of 4, we
2969 use the least significant bit to record whether
2970 we have initialized it already.
2971
2972 When doing a dynamic link, we create a .rela.got
2973 relocation entry to initialize the value. This
2974 is done in the finish_dynamic_symbol routine. */
2975 if ((off & 1) != 0)
2976 off &= ~1;
2977 else
2978 {
2979 bfd_put_32 (output_bfd, relocation,
2980 sgot->contents + off);
2981 h->got.offset |= 1;
2982 }
2983 }
2984 else
2985 unresolved_reloc = FALSE;
2986 }
2987 else
2988 {
2989 BFD_ASSERT (local_got_offsets != NULL);
2990 off = local_got_offsets[r_symndx];
2991 BFD_ASSERT (off != (bfd_vma) - 1);
2992
2993 /* The offset must always be a multiple of 4. We use
2994 the least significant bit to record whether we have
2995 already generated the necessary reloc. */
2996 if ((off & 1) != 0)
2997 off &= ~1;
2998 else
2999 {
3000 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
3001
3002 if (info->shared)
3003 {
3004 asection *s;
3005 Elf_Internal_Rela outrel;
3006 bfd_byte *loc;
3007
3008 s = bfd_get_section_by_name (dynobj, ".rela.got");
3009 BFD_ASSERT (s != NULL);
3010
3011 outrel.r_offset = (sgot->output_section->vma
3012 + sgot->output_offset + off);
3013 outrel.r_info =
3014 ELF32_R_INFO (0, R_pcrel24);
3015 outrel.r_addend = relocation;
3016 loc = s->contents;
3017 loc +=
3018 s->reloc_count++ * sizeof (Elf32_External_Rela);
3019 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3020 }
3021
3022 local_got_offsets[r_symndx] |= 1;
3023 }
3024 }
3025
3026 relocation = sgot->output_offset + off;
3027 rel->r_addend = 0;
3028 /* bfin : preg = [preg + 17bitdiv4offset] relocation is div by 4. */
3029 relocation /= 4;
3030 }
3031 goto do_default;
3032
3033 case R_pcrel24:
3034 case R_pcrel24_jump_l:
3035 {
3036 bfd_vma x;
3037
3038 relocation += rel->r_addend;
3039
3040 /* Perform usual pc-relative correction. */
3041 relocation -= input_section->output_section->vma + input_section->output_offset;
3042 relocation -= address;
3043
3044 /* We are getting reloc_entry->address 2 byte off from
3045 the start of instruction. Assuming absolute postion
3046 of the reloc data. But, following code had been written assuming
3047 reloc address is starting at begining of instruction.
3048 To compensate that I have increased the value of
3049 relocation by 1 (effectively 2) and used the addr -2 instead of addr. */
3050
3051 relocation += 2;
3052 address -= 2;
3053
3054 relocation >>= 1;
3055
3056 x = bfd_get_16 (input_bfd, contents + address);
3057 x = (x & 0xff00) | ((relocation >> 16) & 0xff);
3058 bfd_put_16 (input_bfd, x, contents + address);
3059
3060 x = bfd_get_16 (input_bfd, contents + address + 2);
3061 x = relocation & 0xFFFF;
3062 bfd_put_16 (input_bfd, x, contents + address + 2);
3063 r = bfd_reloc_ok;
3064 }
3065 break;
3066
3067 default:
3068 do_default:
3069 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3070 contents, address,
3071 relocation, rel->r_addend);
3072
3073 break;
3074 }
3075
3076 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3077 because such sections are not SEC_ALLOC and thus ld.so will
3078 not process them. */
3079 if (unresolved_reloc
3080 && !((input_section->flags & SEC_DEBUGGING) != 0 && h->def_dynamic))
3081 {
3082 (*_bfd_error_handler)
3083 (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
3084 input_bfd,
3085 input_section, (long) rel->r_offset, h->root.root.string);
3086 return FALSE;
3087 }
3088
3089 if (r != bfd_reloc_ok)
3090 {
3091 const char *name;
3092
3093 if (h != NULL)
3094 name = h->root.root.string;
3095 else
3096 {
3097 name = bfd_elf_string_from_elf_section (input_bfd,
3098 symtab_hdr->sh_link,
3099 sym->st_name);
3100 if (name == NULL)
3101 return FALSE;
3102 if (*name == '\0')
3103 name = bfd_section_name (input_bfd, sec);
3104 }
3105
3106 if (r == bfd_reloc_overflow)
3107 {
3108 if (!(info->callbacks->reloc_overflow
3109 (info, (h ? &h->root : NULL), name, howto->name,
3110 (bfd_vma) 0, input_bfd, input_section, rel->r_offset)))
3111 return FALSE;
3112 }
3113 else
3114 {
3115 (*_bfd_error_handler)
3116 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3117 input_bfd, input_section,
3118 (long) rel->r_offset, name, (int) r);
3119 return FALSE;
3120 }
3121 }
3122 }
3123
3124 return TRUE;
3125 }
3126
3127 static asection *
3128 bfin_gc_mark_hook (asection * sec,
3129 struct bfd_link_info *info,
3130 Elf_Internal_Rela * rel,
3131 struct elf_link_hash_entry *h,
3132 Elf_Internal_Sym * sym)
3133 {
3134 if (h != NULL)
3135 switch (ELF32_R_TYPE (rel->r_info))
3136 {
3137 case R_BFIN_GNU_VTINHERIT:
3138 case R_BFIN_GNU_VTENTRY:
3139 return NULL;
3140 }
3141
3142 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
3143 }
3144
3145 /* Update the got entry reference counts for the section being removed. */
3146
3147 static bfd_boolean
3148 bfin_gc_sweep_hook (bfd * abfd,
3149 struct bfd_link_info *info,
3150 asection * sec,
3151 const Elf_Internal_Rela * relocs)
3152 {
3153 Elf_Internal_Shdr *symtab_hdr;
3154 struct elf_link_hash_entry **sym_hashes;
3155 bfd_signed_vma *local_got_refcounts;
3156 const Elf_Internal_Rela *rel, *relend;
3157 bfd *dynobj;
3158 asection *sgot;
3159 asection *srelgot;
3160
3161 dynobj = elf_hash_table (info)->dynobj;
3162 if (dynobj == NULL)
3163 return TRUE;
3164
3165 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3166 sym_hashes = elf_sym_hashes (abfd);
3167 local_got_refcounts = elf_local_got_refcounts (abfd);
3168
3169 sgot = bfd_get_section_by_name (dynobj, ".got");
3170 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3171
3172 relend = relocs + sec->reloc_count;
3173 for (rel = relocs; rel < relend; rel++)
3174 {
3175 unsigned long r_symndx;
3176 struct elf_link_hash_entry *h;
3177
3178 switch (ELF32_R_TYPE (rel->r_info))
3179 {
3180 case R_got:
3181 r_symndx = ELF32_R_SYM (rel->r_info);
3182 if (r_symndx >= symtab_hdr->sh_info)
3183 {
3184 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3185 if (h->got.refcount > 0)
3186 {
3187 --h->got.refcount;
3188 if (h->got.refcount == 0)
3189 {
3190 /* We don't need the .got entry any more. */
3191 sgot->size -= 4;
3192 srelgot->size -= sizeof (Elf32_External_Rela);
3193 }
3194 }
3195 }
3196 else if (local_got_refcounts != NULL)
3197 {
3198 if (local_got_refcounts[r_symndx] > 0)
3199 {
3200 --local_got_refcounts[r_symndx];
3201 if (local_got_refcounts[r_symndx] == 0)
3202 {
3203 /* We don't need the .got entry any more. */
3204 sgot->size -= 4;
3205 if (info->shared)
3206 srelgot->size -= sizeof (Elf32_External_Rela);
3207 }
3208 }
3209 }
3210 break;
3211 default:
3212 break;
3213 }
3214 }
3215 return TRUE;
3216 }
3217
3218 /* We need dynamic symbols for every section, since segments can
3219 relocate independently. */
3220 static bfd_boolean
3221 _bfinfdpic_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
3222 struct bfd_link_info *info
3223 ATTRIBUTE_UNUSED,
3224 asection *p ATTRIBUTE_UNUSED)
3225 {
3226 switch (elf_section_data (p)->this_hdr.sh_type)
3227 {
3228 case SHT_PROGBITS:
3229 case SHT_NOBITS:
3230 /* If sh_type is yet undecided, assume it could be
3231 SHT_PROGBITS/SHT_NOBITS. */
3232 case SHT_NULL:
3233 return FALSE;
3234
3235 /* There shouldn't be section relative relocations
3236 against any other section. */
3237 default:
3238 return TRUE;
3239 }
3240 }
3241
3242 /* Create a .got section, as well as its additional info field. This
3243 is almost entirely copied from
3244 elflink.c:_bfd_elf_create_got_section(). */
3245
3246 static bfd_boolean
3247 _bfin_create_got_section (bfd *abfd, struct bfd_link_info *info)
3248 {
3249 flagword flags, pltflags;
3250 asection *s;
3251 struct elf_link_hash_entry *h;
3252 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3253 int ptralign;
3254 int offset;
3255
3256 /* This function may be called more than once. */
3257 s = bfd_get_section_by_name (abfd, ".got");
3258 if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
3259 return TRUE;
3260
3261 /* Machine specific: although pointers are 32-bits wide, we want the
3262 GOT to be aligned to a 64-bit boundary, such that function
3263 descriptors in it can be accessed with 64-bit loads and
3264 stores. */
3265 ptralign = 3;
3266
3267 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3268 | SEC_LINKER_CREATED);
3269 pltflags = flags;
3270
3271 s = bfd_make_section_with_flags (abfd, ".got", flags);
3272 if (s == NULL
3273 || !bfd_set_section_alignment (abfd, s, ptralign))
3274 return FALSE;
3275
3276 if (bed->want_got_plt)
3277 {
3278 s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
3279 if (s == NULL
3280 || !bfd_set_section_alignment (abfd, s, ptralign))
3281 return FALSE;
3282 }
3283
3284 if (bed->want_got_sym)
3285 {
3286 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
3287 (or .got.plt) section. We don't do this in the linker script
3288 because we don't want to define the symbol if we are not creating
3289 a global offset table. */
3290 h = _bfd_elf_define_linkage_sym (abfd, info, s, "__GLOBAL_OFFSET_TABLE_");
3291 elf_hash_table (info)->hgot = h;
3292 if (h == NULL)
3293 return FALSE;
3294
3295 /* Machine-specific: we want the symbol for executables as
3296 well. */
3297 if (! bfd_elf_link_record_dynamic_symbol (info, h))
3298 return FALSE;
3299 }
3300
3301 /* The first bit of the global offset table is the header. */
3302 s->size += bed->got_header_size;
3303
3304 /* This is the machine-specific part. Create and initialize section
3305 data for the got. */
3306 if (IS_FDPIC (abfd))
3307 {
3308 bfinfdpic_got_section (info) = s;
3309 bfinfdpic_relocs_info (info) = htab_try_create (1,
3310 bfinfdpic_relocs_info_hash,
3311 bfinfdpic_relocs_info_eq,
3312 (htab_del) NULL);
3313 if (! bfinfdpic_relocs_info (info))
3314 return FALSE;
3315
3316 s = bfd_make_section_with_flags (abfd, ".rel.got",
3317 (flags | SEC_READONLY));
3318 if (s == NULL
3319 || ! bfd_set_section_alignment (abfd, s, 2))
3320 return FALSE;
3321
3322 bfinfdpic_gotrel_section (info) = s;
3323
3324 /* Machine-specific. */
3325 s = bfd_make_section_with_flags (abfd, ".rofixup",
3326 (flags | SEC_READONLY));
3327 if (s == NULL
3328 || ! bfd_set_section_alignment (abfd, s, 2))
3329 return FALSE;
3330
3331 bfinfdpic_gotfixup_section (info) = s;
3332 offset = -2048;
3333 flags = BSF_GLOBAL;
3334 }
3335 else
3336 {
3337 offset = 2048;
3338 flags = BSF_GLOBAL | BSF_WEAK;
3339 }
3340
3341 return TRUE;
3342 }
3343
3344 /* Make sure the got and plt sections exist, and that our pointers in
3345 the link hash table point to them. */
3346
3347 static bfd_boolean
3348 elf32_bfinfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3349 {
3350 /* This is mostly copied from
3351 elflink.c:_bfd_elf_create_dynamic_sections(). */
3352 flagword flags, pltflags;
3353 asection *s;
3354 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3355
3356 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3357 .rel[a].bss sections. */
3358
3359 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3360 | SEC_LINKER_CREATED);
3361
3362 pltflags = flags;
3363 pltflags |= SEC_CODE;
3364 if (bed->plt_not_loaded)
3365 pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
3366 if (bed->plt_readonly)
3367 pltflags |= SEC_READONLY;
3368
3369 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
3370 if (s == NULL
3371 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3372 return FALSE;
3373 /* Blackfin-specific: remember it. */
3374 bfinfdpic_plt_section (info) = s;
3375
3376 if (bed->want_plt_sym)
3377 {
3378 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3379 .plt section. */
3380 struct elf_link_hash_entry *h;
3381 struct bfd_link_hash_entry *bh = NULL;
3382
3383 if (! (_bfd_generic_link_add_one_symbol
3384 (info, abfd, "__PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 0, NULL,
3385 FALSE, get_elf_backend_data (abfd)->collect, &bh)))
3386 return FALSE;
3387 h = (struct elf_link_hash_entry *) bh;
3388 h->def_regular = 1;
3389 h->type = STT_OBJECT;
3390
3391 if (! info->executable
3392 && ! bfd_elf_link_record_dynamic_symbol (info, h))
3393 return FALSE;
3394 }
3395
3396 /* Blackfin-specific: we want rel relocations for the plt. */
3397 s = bfd_make_section_with_flags (abfd, ".rel.plt", flags | SEC_READONLY);
3398 if (s == NULL
3399 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
3400 return FALSE;
3401 /* Blackfin-specific: remember it. */
3402 bfinfdpic_pltrel_section (info) = s;
3403
3404 /* Blackfin-specific: we want to create the GOT in the Blackfin way. */
3405 if (! _bfin_create_got_section (abfd, info))
3406 return FALSE;
3407
3408 /* Blackfin-specific: make sure we created everything we wanted. */
3409 BFD_ASSERT (bfinfdpic_got_section (info) && bfinfdpic_gotrel_section (info)
3410 /* && bfinfdpic_gotfixup_section (info) */
3411 && bfinfdpic_plt_section (info)
3412 && bfinfdpic_pltrel_section (info));
3413
3414 if (bed->want_dynbss)
3415 {
3416 /* The .dynbss section is a place to put symbols which are defined
3417 by dynamic objects, are referenced by regular objects, and are
3418 not functions. We must allocate space for them in the process
3419 image and use a R_*_COPY reloc to tell the dynamic linker to
3420 initialize them at run time. The linker script puts the .dynbss
3421 section into the .bss section of the final image. */
3422 s = bfd_make_section_with_flags (abfd, ".dynbss",
3423 SEC_ALLOC | SEC_LINKER_CREATED);
3424 if (s == NULL)
3425 return FALSE;
3426
3427 /* The .rel[a].bss section holds copy relocs. This section is not
3428 normally needed. We need to create it here, though, so that the
3429 linker will map it to an output section. We can't just create it
3430 only if we need it, because we will not know whether we need it
3431 until we have seen all the input files, and the first time the
3432 main linker code calls BFD after examining all the input files
3433 (size_dynamic_sections) the input sections have already been
3434 mapped to the output sections. If the section turns out not to
3435 be needed, we can discard it later. We will never need this
3436 section when generating a shared object, since they do not use
3437 copy relocs. */
3438 if (! info->shared)
3439 {
3440 s = bfd_make_section_with_flags (abfd,
3441 (bed->default_use_rela_p
3442 ? ".rela.bss" : ".rel.bss"),
3443 flags | SEC_READONLY);
3444 if (s == NULL
3445 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
3446 return FALSE;
3447 }
3448 }
3449
3450 return TRUE;
3451 }
3452
3453 /* The name of the dynamic interpreter. This is put in the .interp
3454 section. */
3455
3456 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
3457
3458 #define DEFAULT_STACK_SIZE 0x20000
3459
3460 /* This structure is used to collect the number of entries present in
3461 each addressable range of the got. */
3462 struct _bfinfdpic_dynamic_got_info
3463 {
3464 /* Several bits of information about the current link. */
3465 struct bfd_link_info *info;
3466 /* Total size needed for GOT entries within the 18- or 32-bit
3467 ranges. */
3468 bfd_vma got17m4, gothilo;
3469 /* Total size needed for function descriptor entries within the 18-
3470 or 32-bit ranges. */
3471 bfd_vma fd17m4, fdhilo;
3472 /* Total size needed function descriptor entries referenced in PLT
3473 entries, that would be profitable to place in offsets close to
3474 the PIC register. */
3475 bfd_vma fdplt;
3476 /* Total size needed by lazy PLT entries. */
3477 bfd_vma lzplt;
3478 /* Number of relocations carried over from input object files. */
3479 unsigned long relocs;
3480 /* Number of fixups introduced by relocations in input object files. */
3481 unsigned long fixups;
3482 };
3483
3484 /* Compute the total GOT size required by each symbol in each range.
3485 Symbols may require up to 4 words in the GOT: an entry pointing to
3486 the symbol, an entry pointing to its function descriptor, and a
3487 private function descriptors taking two words. */
3488
3489 static int
3490 _bfinfdpic_count_got_plt_entries (void **entryp, void *dinfo_)
3491 {
3492 struct bfinfdpic_relocs_info *entry = *entryp;
3493 struct _bfinfdpic_dynamic_got_info *dinfo = dinfo_;
3494 unsigned relocs = 0, fixups = 0;
3495
3496 /* Allocate space for a GOT entry pointing to the symbol. */
3497 if (entry->got17m4)
3498 dinfo->got17m4 += 4;
3499 else if (entry->gothilo)
3500 dinfo->gothilo += 4;
3501 else
3502 entry->relocs32--;
3503 entry->relocs32++;
3504
3505 /* Allocate space for a GOT entry pointing to the function
3506 descriptor. */
3507 if (entry->fdgot17m4)
3508 dinfo->got17m4 += 4;
3509 else if (entry->fdgothilo)
3510 dinfo->gothilo += 4;
3511 else
3512 entry->relocsfd--;
3513 entry->relocsfd++;
3514
3515 /* Decide whether we need a PLT entry, a function descriptor in the
3516 GOT, and a lazy PLT entry for this symbol. */
3517 entry->plt = entry->call
3518 && entry->symndx == -1 && ! BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
3519 && elf_hash_table (dinfo->info)->dynamic_sections_created;
3520 entry->privfd = entry->plt
3521 || entry->fdgoff17m4 || entry->fdgoffhilo
3522 || ((entry->fd || entry->fdgot17m4 || entry->fdgothilo)
3523 && (entry->symndx != -1
3524 || BFINFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
3525 entry->lazyplt = entry->privfd
3526 && entry->symndx == -1 && ! BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
3527 && ! (dinfo->info->flags & DF_BIND_NOW)
3528 && elf_hash_table (dinfo->info)->dynamic_sections_created;
3529
3530 /* Allocate space for a function descriptor. */
3531 if (entry->fdgoff17m4)
3532 dinfo->fd17m4 += 8;
3533 else if (entry->privfd && entry->plt)
3534 dinfo->fdplt += 8;
3535 else if (entry->privfd)
3536 dinfo->fdhilo += 8;
3537 else
3538 entry->relocsfdv--;
3539 entry->relocsfdv++;
3540
3541 if (entry->lazyplt)
3542 dinfo->lzplt += LZPLT_NORMAL_SIZE;
3543
3544 if (!dinfo->info->executable || dinfo->info->pie)
3545 relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv;
3546 else
3547 {
3548 if (entry->symndx != -1 || BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))
3549 {
3550 if (entry->symndx != -1
3551 || entry->d.h->root.type != bfd_link_hash_undefweak)
3552 fixups += entry->relocs32 + 2 * entry->relocsfdv;
3553 }
3554 else
3555 relocs += entry->relocs32 + entry->relocsfdv;
3556
3557 if (entry->symndx != -1
3558 || BFINFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
3559 {
3560 if (entry->symndx != -1
3561 || entry->d.h->root.type != bfd_link_hash_undefweak)
3562 fixups += entry->relocsfd;
3563 }
3564 else
3565 relocs += entry->relocsfd;
3566 }
3567
3568 entry->dynrelocs += relocs;
3569 entry->fixups += fixups;
3570 dinfo->relocs += relocs;
3571 dinfo->fixups += fixups;
3572
3573 return 1;
3574 }
3575
3576 /* This structure is used to assign offsets to got entries, function
3577 descriptors, plt entries and lazy plt entries. */
3578
3579 struct _bfinfdpic_dynamic_got_plt_info
3580 {
3581 /* Summary information collected with _bfinfdpic_count_got_plt_entries. */
3582 struct _bfinfdpic_dynamic_got_info g;
3583
3584 /* For each addressable range, we record a MAX (positive) and MIN
3585 (negative) value. CUR is used to assign got entries, and it's
3586 incremented from an initial positive value to MAX, then from MIN
3587 to FDCUR (unless FDCUR wraps around first). FDCUR is used to
3588 assign function descriptors, and it's decreased from an initial
3589 non-positive value to MIN, then from MAX down to CUR (unless CUR
3590 wraps around first). All of MIN, MAX, CUR and FDCUR always point
3591 to even words. ODD, if non-zero, indicates an odd word to be
3592 used for the next got entry, otherwise CUR is used and
3593 incremented by a pair of words, wrapping around when it reaches
3594 MAX. FDCUR is decremented (and wrapped) before the next function
3595 descriptor is chosen. FDPLT indicates the number of remaining
3596 slots that can be used for function descriptors used only by PLT
3597 entries. */
3598 struct _bfinfdpic_dynamic_got_alloc_data
3599 {
3600 bfd_signed_vma max, cur, odd, fdcur, min;
3601 bfd_vma fdplt;
3602 } got17m4, gothilo;
3603 };
3604
3605 /* Determine the positive and negative ranges to be used by each
3606 offset range in the GOT. FDCUR and CUR, that must be aligned to a
3607 double-word boundary, are the minimum (negative) and maximum
3608 (positive) GOT offsets already used by previous ranges, except for
3609 an ODD entry that may have been left behind. GOT and FD indicate
3610 the size of GOT entries and function descriptors that must be
3611 placed within the range from -WRAP to WRAP. If there's room left,
3612 up to FDPLT bytes should be reserved for additional function
3613 descriptors. */
3614
3615 inline static bfd_signed_vma
3616 _bfinfdpic_compute_got_alloc_data (struct _bfinfdpic_dynamic_got_alloc_data *gad,
3617 bfd_signed_vma fdcur,
3618 bfd_signed_vma odd,
3619 bfd_signed_vma cur,
3620 bfd_vma got,
3621 bfd_vma fd,
3622 bfd_vma fdplt,
3623 bfd_vma wrap)
3624 {
3625 bfd_signed_vma wrapmin = -wrap;
3626
3627 /* Start at the given initial points. */
3628 gad->fdcur = fdcur;
3629 gad->cur = cur;
3630
3631 /* If we had an incoming odd word and we have any got entries that
3632 are going to use it, consume it, otherwise leave gad->odd at
3633 zero. We might force gad->odd to zero and return the incoming
3634 odd such that it is used by the next range, but then GOT entries
3635 might appear to be out of order and we wouldn't be able to
3636 shorten the GOT by one word if it turns out to end with an
3637 unpaired GOT entry. */
3638 if (odd && got)
3639 {
3640 gad->odd = odd;
3641 got -= 4;
3642 odd = 0;
3643 }
3644 else
3645 gad->odd = 0;
3646
3647 /* If we're left with an unpaired GOT entry, compute its location
3648 such that we can return it. Otherwise, if got doesn't require an
3649 odd number of words here, either odd was already zero in the
3650 block above, or it was set to zero because got was non-zero, or
3651 got was already zero. In the latter case, we want the value of
3652 odd to carry over to the return statement, so we don't want to
3653 reset odd unless the condition below is true. */
3654 if (got & 4)
3655 {
3656 odd = cur + got;
3657 got += 4;
3658 }
3659
3660 /* Compute the tentative boundaries of this range. */
3661 gad->max = cur + got;
3662 gad->min = fdcur - fd;
3663 gad->fdplt = 0;
3664
3665 /* If function descriptors took too much space, wrap some of them
3666 around. */
3667 if (gad->min < wrapmin)
3668 {
3669 gad->max += wrapmin - gad->min;
3670 gad->min = wrapmin;
3671 }
3672 /* If there is space left and we have function descriptors
3673 referenced in PLT entries that could take advantage of shorter
3674 offsets, place them here. */
3675 else if (fdplt && gad->min > wrapmin)
3676 {
3677 bfd_vma fds;
3678 if ((bfd_vma) (gad->min - wrapmin) < fdplt)
3679 fds = gad->min - wrapmin;
3680 else
3681 fds = fdplt;
3682
3683 fdplt -= fds;
3684 gad->min -= fds;
3685 gad->fdplt += fds;
3686 }
3687
3688 /* If GOT entries took too much space, wrap some of them around.
3689 This may well cause gad->min to become lower than wrapmin. This
3690 will cause a relocation overflow later on, so we don't have to
3691 report it here . */
3692 if ((bfd_vma) gad->max > wrap)
3693 {
3694 gad->min -= gad->max - wrap;
3695 gad->max = wrap;
3696 }
3697 /* If there is more space left, try to place some more function
3698 descriptors for PLT entries. */
3699 else if (fdplt && (bfd_vma) gad->max < wrap)
3700 {
3701 bfd_vma fds;
3702 if ((bfd_vma) (wrap - gad->max) < fdplt)
3703 fds = wrap - gad->max;
3704 else
3705 fds = fdplt;
3706
3707 fdplt -= fds;
3708 gad->max += fds;
3709 gad->fdplt += fds;
3710 }
3711
3712 /* If odd was initially computed as an offset past the wrap point,
3713 wrap it around. */
3714 if (odd > gad->max)
3715 odd = gad->min + odd - gad->max;
3716
3717 /* _bfinfdpic_get_got_entry() below will always wrap gad->cur if needed
3718 before returning, so do it here too. This guarantees that,
3719 should cur and fdcur meet at the wrap point, they'll both be
3720 equal to min. */
3721 if (gad->cur == gad->max)
3722 gad->cur = gad->min;
3723
3724 return odd;
3725 }
3726
3727 /* Compute the location of the next GOT entry, given the allocation
3728 data for a range. */
3729
3730 inline static bfd_signed_vma
3731 _bfinfdpic_get_got_entry (struct _bfinfdpic_dynamic_got_alloc_data *gad)
3732 {
3733 bfd_signed_vma ret;
3734
3735 if (gad->odd)
3736 {
3737 /* If there was an odd word left behind, use it. */
3738 ret = gad->odd;
3739 gad->odd = 0;
3740 }
3741 else
3742 {
3743 /* Otherwise, use the word pointed to by cur, reserve the next
3744 as an odd word, and skip to the next pair of words, possibly
3745 wrapping around. */
3746 ret = gad->cur;
3747 gad->odd = gad->cur + 4;
3748 gad->cur += 8;
3749 if (gad->cur == gad->max)
3750 gad->cur = gad->min;
3751 }
3752
3753 return ret;
3754 }
3755
3756 /* Compute the location of the next function descriptor entry in the
3757 GOT, given the allocation data for a range. */
3758
3759 inline static bfd_signed_vma
3760 _bfinfdpic_get_fd_entry (struct _bfinfdpic_dynamic_got_alloc_data *gad)
3761 {
3762 /* If we're at the bottom, wrap around, and only then allocate the
3763 next pair of words. */
3764 if (gad->fdcur == gad->min)
3765 gad->fdcur = gad->max;
3766 return gad->fdcur -= 8;
3767 }
3768
3769 /* Assign GOT offsets for every GOT entry and function descriptor.
3770 Doing everything in a single pass is tricky. */
3771
3772 static int
3773 _bfinfdpic_assign_got_entries (void **entryp, void *info_)
3774 {
3775 struct bfinfdpic_relocs_info *entry = *entryp;
3776 struct _bfinfdpic_dynamic_got_plt_info *dinfo = info_;
3777
3778 if (entry->got17m4)
3779 entry->got_entry = _bfinfdpic_get_got_entry (&dinfo->got17m4);
3780 else if (entry->gothilo)
3781 entry->got_entry = _bfinfdpic_get_got_entry (&dinfo->gothilo);
3782
3783 if (entry->fdgot17m4)
3784 entry->fdgot_entry = _bfinfdpic_get_got_entry (&dinfo->got17m4);
3785 else if (entry->fdgothilo)
3786 entry->fdgot_entry = _bfinfdpic_get_got_entry (&dinfo->gothilo);
3787
3788 if (entry->fdgoff17m4)
3789 entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3790 else if (entry->plt && dinfo->got17m4.fdplt)
3791 {
3792 dinfo->got17m4.fdplt -= 8;
3793 entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3794 }
3795 else if (entry->plt)
3796 {
3797 dinfo->gothilo.fdplt -= 8;
3798 entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3799 }
3800 else if (entry->privfd)
3801 entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3802
3803 return 1;
3804 }
3805
3806 /* Assign GOT offsets to private function descriptors used by PLT
3807 entries (or referenced by 32-bit offsets), as well as PLT entries
3808 and lazy PLT entries. */
3809
3810 static int
3811 _bfinfdpic_assign_plt_entries (void **entryp, void *info_)
3812 {
3813 struct bfinfdpic_relocs_info *entry = *entryp;
3814 struct _bfinfdpic_dynamic_got_plt_info *dinfo = info_;
3815
3816 /* If this symbol requires a local function descriptor, allocate
3817 one. */
3818 if (entry->privfd && entry->fd_entry == 0)
3819 {
3820 if (dinfo->got17m4.fdplt)
3821 {
3822 entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3823 dinfo->got17m4.fdplt -= 8;
3824 }
3825 else
3826 {
3827 BFD_ASSERT (dinfo->gothilo.fdplt);
3828 entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3829 dinfo->gothilo.fdplt -= 8;
3830 }
3831 }
3832
3833 if (entry->plt)
3834 {
3835 int size;
3836
3837 /* We use the section's raw size to mark the location of the
3838 next PLT entry. */
3839 entry->plt_entry = bfinfdpic_plt_section (dinfo->g.info)->size;
3840
3841 /* Figure out the length of this PLT entry based on the
3842 addressing mode we need to reach the function descriptor. */
3843 BFD_ASSERT (entry->fd_entry);
3844 if (entry->fd_entry >= -(1 << (18 - 1))
3845 && entry->fd_entry + 4 < (1 << (18 - 1)))
3846 size = 10;
3847 else
3848 size = 16;
3849
3850 bfinfdpic_plt_section (dinfo->g.info)->size += size;
3851 }
3852
3853 if (entry->lazyplt)
3854 {
3855 entry->lzplt_entry = dinfo->g.lzplt;
3856 dinfo->g.lzplt += LZPLT_NORMAL_SIZE;
3857 /* If this entry is the one that gets the resolver stub, account
3858 for the additional instruction. */
3859 if (entry->lzplt_entry % BFINFDPIC_LZPLT_BLOCK_SIZE
3860 == BFINFDPIC_LZPLT_RESOLV_LOC)
3861 dinfo->g.lzplt += LZPLT_RESOLVER_EXTRA;
3862 }
3863
3864 return 1;
3865 }
3866
3867 /* Follow indirect and warning hash entries so that each got entry
3868 points to the final symbol definition. P must point to a pointer
3869 to the hash table we're traversing. Since this traversal may
3870 modify the hash table, we set this pointer to NULL to indicate
3871 we've made a potentially-destructive change to the hash table, so
3872 the traversal must be restarted. */
3873 static int
3874 _bfinfdpic_resolve_final_relocs_info (void **entryp, void *p)
3875 {
3876 struct bfinfdpic_relocs_info *entry = *entryp;
3877 htab_t *htab = p;
3878
3879 if (entry->symndx == -1)
3880 {
3881 struct elf_link_hash_entry *h = entry->d.h;
3882 struct bfinfdpic_relocs_info *oentry;
3883
3884 while (h->root.type == bfd_link_hash_indirect
3885 || h->root.type == bfd_link_hash_warning)
3886 h = (struct elf_link_hash_entry *)h->root.u.i.link;
3887
3888 if (entry->d.h == h)
3889 return 1;
3890
3891 oentry = bfinfdpic_relocs_info_for_global (*htab, 0, h, entry->addend,
3892 NO_INSERT);
3893
3894 if (oentry)
3895 {
3896 /* Merge the two entries. */
3897 bfinfdpic_pic_merge_early_relocs_info (oentry, entry);
3898 htab_clear_slot (*htab, entryp);
3899 return 1;
3900 }
3901
3902 entry->d.h = h;
3903
3904 /* If we can't find this entry with the new bfd hash, re-insert
3905 it, and get the traversal restarted. */
3906 if (! htab_find (*htab, entry))
3907 {
3908 htab_clear_slot (*htab, entryp);
3909 entryp = htab_find_slot (*htab, entry, INSERT);
3910 if (! *entryp)
3911 *entryp = entry;
3912 /* Abort the traversal, since the whole table may have
3913 moved, and leave it up to the parent to restart the
3914 process. */
3915 *(htab_t *)p = NULL;
3916 return 0;
3917 }
3918 }
3919
3920 return 1;
3921 }
3922
3923 /* Set the sizes of the dynamic sections. */
3924
3925 static bfd_boolean
3926 elf32_bfinfdpic_size_dynamic_sections (bfd *output_bfd,
3927 struct bfd_link_info *info)
3928 {
3929 bfd *dynobj;
3930 asection *s;
3931 struct _bfinfdpic_dynamic_got_plt_info gpinfo;
3932 bfd_signed_vma odd;
3933 bfd_vma limit;
3934
3935 dynobj = elf_hash_table (info)->dynobj;
3936 BFD_ASSERT (dynobj != NULL);
3937
3938 if (elf_hash_table (info)->dynamic_sections_created)
3939 {
3940 /* Set the contents of the .interp section to the interpreter. */
3941 if (info->executable)
3942 {
3943 s = bfd_get_section_by_name (dynobj, ".interp");
3944 BFD_ASSERT (s != NULL);
3945 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3946 s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
3947 }
3948 }
3949
3950 memset (&gpinfo, 0, sizeof (gpinfo));
3951 gpinfo.g.info = info;
3952
3953 for (;;)
3954 {
3955 htab_t relocs = bfinfdpic_relocs_info (info);
3956
3957 htab_traverse (relocs, _bfinfdpic_resolve_final_relocs_info, &relocs);
3958
3959 if (relocs == bfinfdpic_relocs_info (info))
3960 break;
3961 }
3962
3963 htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_count_got_plt_entries,
3964 &gpinfo.g);
3965
3966 odd = 12;
3967 /* Compute the total size taken by entries in the 18-bit range,
3968 to tell how many PLT function descriptors we can bring into it
3969 without causing it to overflow. */
3970 limit = odd + gpinfo.g.got17m4 + gpinfo.g.fd17m4;
3971 if (limit < (bfd_vma)1 << 18)
3972 limit = ((bfd_vma)1 << 18) - limit;
3973 else
3974 limit = 0;
3975 if (gpinfo.g.fdplt < limit)
3976 limit = gpinfo.g.fdplt;
3977
3978 /* Determine the ranges of GOT offsets that we can use for each
3979 range of addressing modes. */
3980 odd = _bfinfdpic_compute_got_alloc_data (&gpinfo.got17m4,
3981 0,
3982 odd,
3983 16,
3984 gpinfo.g.got17m4,
3985 gpinfo.g.fd17m4,
3986 limit,
3987 (bfd_vma)1 << (18-1));
3988 odd = _bfinfdpic_compute_got_alloc_data (&gpinfo.gothilo,
3989 gpinfo.got17m4.min,
3990 odd,
3991 gpinfo.got17m4.max,
3992 gpinfo.g.gothilo,
3993 gpinfo.g.fdhilo,
3994 gpinfo.g.fdplt - gpinfo.got17m4.fdplt,
3995 (bfd_vma)1 << (32-1));
3996
3997 /* Now assign (most) GOT offsets. */
3998 htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_assign_got_entries,
3999 &gpinfo);
4000
4001 bfinfdpic_got_section (info)->size = gpinfo.gothilo.max
4002 - gpinfo.gothilo.min
4003 /* If an odd word is the last word of the GOT, we don't need this
4004 word to be part of the GOT. */
4005 - (odd + 4 == gpinfo.gothilo.max ? 4 : 0);
4006 if (bfinfdpic_got_section (info)->size == 0)
4007 bfinfdpic_got_section (info)->flags |= SEC_EXCLUDE;
4008 else if (bfinfdpic_got_section (info)->size == 12
4009 && ! elf_hash_table (info)->dynamic_sections_created)
4010 {
4011 bfinfdpic_got_section (info)->flags |= SEC_EXCLUDE;
4012 bfinfdpic_got_section (info)->size = 0;
4013 }
4014 else
4015 {
4016 bfinfdpic_got_section (info)->contents =
4017 (bfd_byte *) bfd_zalloc (dynobj,
4018 bfinfdpic_got_section (info)->size);
4019 if (bfinfdpic_got_section (info)->contents == NULL)
4020 return FALSE;
4021 }
4022
4023 if (elf_hash_table (info)->dynamic_sections_created)
4024 /* Subtract the number of lzplt entries, since those will generate
4025 relocations in the pltrel section. */
4026 bfinfdpic_gotrel_section (info)->size =
4027 (gpinfo.g.relocs - gpinfo.g.lzplt / LZPLT_NORMAL_SIZE)
4028 * get_elf_backend_data (output_bfd)->s->sizeof_rel;
4029 else
4030 BFD_ASSERT (gpinfo.g.relocs == 0);
4031 if (bfinfdpic_gotrel_section (info)->size == 0)
4032 bfinfdpic_gotrel_section (info)->flags |= SEC_EXCLUDE;
4033 else
4034 {
4035 bfinfdpic_gotrel_section (info)->contents =
4036 (bfd_byte *) bfd_zalloc (dynobj,
4037 bfinfdpic_gotrel_section (info)->size);
4038 if (bfinfdpic_gotrel_section (info)->contents == NULL)
4039 return FALSE;
4040 }
4041
4042 bfinfdpic_gotfixup_section (info)->size = (gpinfo.g.fixups + 1) * 4;
4043 if (bfinfdpic_gotfixup_section (info)->size == 0)
4044 bfinfdpic_gotfixup_section (info)->flags |= SEC_EXCLUDE;
4045 else
4046 {
4047 bfinfdpic_gotfixup_section (info)->contents =
4048 (bfd_byte *) bfd_zalloc (dynobj,
4049 bfinfdpic_gotfixup_section (info)->size);
4050 if (bfinfdpic_gotfixup_section (info)->contents == NULL)
4051 return FALSE;
4052 }
4053
4054 if (elf_hash_table (info)->dynamic_sections_created)
4055 {
4056 bfinfdpic_pltrel_section (info)->size =
4057 gpinfo.g.lzplt / LZPLT_NORMAL_SIZE * get_elf_backend_data (output_bfd)->s->sizeof_rel;
4058 if (bfinfdpic_pltrel_section (info)->size == 0)
4059 bfinfdpic_pltrel_section (info)->flags |= SEC_EXCLUDE;
4060 else
4061 {
4062 bfinfdpic_pltrel_section (info)->contents =
4063 (bfd_byte *) bfd_zalloc (dynobj,
4064 bfinfdpic_pltrel_section (info)->size);
4065 if (bfinfdpic_pltrel_section (info)->contents == NULL)
4066 return FALSE;
4067 }
4068 }
4069
4070 /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
4071 such that there's room for the additional instruction needed to
4072 call the resolver. Since _bfinfdpic_assign_got_entries didn't
4073 account for them, our block size is 4 bytes smaller than the real
4074 block size. */
4075 if (elf_hash_table (info)->dynamic_sections_created)
4076 {
4077 bfinfdpic_plt_section (info)->size = gpinfo.g.lzplt
4078 + ((gpinfo.g.lzplt + (BFINFDPIC_LZPLT_BLOCK_SIZE - 4) - LZPLT_NORMAL_SIZE)
4079 / (BFINFDPIC_LZPLT_BLOCK_SIZE - 4) * LZPLT_RESOLVER_EXTRA);
4080 }
4081
4082 /* Reset it, such that _bfinfdpic_assign_plt_entries() can use it to
4083 actually assign lazy PLT entries addresses. */
4084 gpinfo.g.lzplt = 0;
4085
4086 /* Save information that we're going to need to generate GOT and PLT
4087 entries. */
4088 bfinfdpic_got_initial_offset (info) = -gpinfo.gothilo.min;
4089
4090 if (get_elf_backend_data (output_bfd)->want_got_sym)
4091 elf_hash_table (info)->hgot->root.u.def.value
4092 += bfinfdpic_got_initial_offset (info);
4093
4094 if (elf_hash_table (info)->dynamic_sections_created)
4095 bfinfdpic_plt_initial_offset (info) =
4096 bfinfdpic_plt_section (info)->size;
4097
4098 htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_assign_plt_entries,
4099 &gpinfo);
4100
4101 /* Allocate the PLT section contents only after
4102 _bfinfdpic_assign_plt_entries has a chance to add the size of the
4103 non-lazy PLT entries. */
4104 if (elf_hash_table (info)->dynamic_sections_created)
4105 {
4106 if (bfinfdpic_plt_section (info)->size == 0)
4107 bfinfdpic_plt_section (info)->flags |= SEC_EXCLUDE;
4108 else
4109 {
4110 bfinfdpic_plt_section (info)->contents =
4111 (bfd_byte *) bfd_zalloc (dynobj,
4112 bfinfdpic_plt_section (info)->size);
4113 if (bfinfdpic_plt_section (info)->contents == NULL)
4114 return FALSE;
4115 }
4116 }
4117
4118 if (elf_hash_table (info)->dynamic_sections_created)
4119 {
4120 if (bfinfdpic_got_section (info)->size)
4121 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0))
4122 return FALSE;
4123
4124 if (bfinfdpic_pltrel_section (info)->size)
4125 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
4126 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_REL)
4127 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
4128 return FALSE;
4129
4130 if (bfinfdpic_gotrel_section (info)->size)
4131 if (!_bfd_elf_add_dynamic_entry (info, DT_REL, 0)
4132 || !_bfd_elf_add_dynamic_entry (info, DT_RELSZ, 0)
4133 || !_bfd_elf_add_dynamic_entry (info, DT_RELENT,
4134 sizeof (Elf32_External_Rel)))
4135 return FALSE;
4136 }
4137
4138 return TRUE;
4139 }
4140
4141 static bfd_boolean
4142 elf32_bfinfdpic_always_size_sections (bfd *output_bfd,
4143 struct bfd_link_info *info)
4144 {
4145 if (!info->relocatable)
4146 {
4147 struct elf_link_hash_entry *h;
4148
4149 /* Force a PT_GNU_STACK segment to be created. */
4150 if (! elf_tdata (output_bfd)->stack_flags)
4151 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
4152
4153 /* Define __stacksize if it's not defined yet. */
4154 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
4155 FALSE, FALSE, FALSE);
4156 if (! h || h->root.type != bfd_link_hash_defined
4157 || h->type != STT_OBJECT
4158 || !h->def_regular)
4159 {
4160 struct bfd_link_hash_entry *bh = NULL;
4161
4162 if (!(_bfd_generic_link_add_one_symbol
4163 (info, output_bfd, "__stacksize",
4164 BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
4165 (const char *) NULL, FALSE,
4166 get_elf_backend_data (output_bfd)->collect, &bh)))
4167 return FALSE;
4168
4169 h = (struct elf_link_hash_entry *) bh;
4170 h->def_regular = 1;
4171 h->type = STT_OBJECT;
4172 }
4173 }
4174
4175 return TRUE;
4176 }
4177
4178 static bfd_boolean
4179 elf32_bfinfdpic_modify_program_headers (bfd *output_bfd,
4180 struct bfd_link_info *info)
4181 {
4182 struct elf_obj_tdata *tdata = elf_tdata (output_bfd);
4183 struct elf_segment_map *m;
4184 Elf_Internal_Phdr *p;
4185
4186 /* objcopy and strip preserve what's already there using
4187 elf32_bfinfdpic_copy_private_bfd_data (). */
4188 if (! info)
4189 return TRUE;
4190
4191 for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++)
4192 if (m->p_type == PT_GNU_STACK)
4193 break;
4194
4195 if (m)
4196 {
4197 struct elf_link_hash_entry *h;
4198
4199 /* Obtain the pointer to the __stacksize symbol. */
4200 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
4201 FALSE, FALSE, FALSE);
4202 if (h)
4203 {
4204 while (h->root.type == bfd_link_hash_indirect
4205 || h->root.type == bfd_link_hash_warning)
4206 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4207 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
4208 }
4209
4210 /* Set the header p_memsz from the symbol value. We
4211 intentionally ignore the symbol section. */
4212 if (h && h->root.type == bfd_link_hash_defined)
4213 p->p_memsz = h->root.u.def.value;
4214 else
4215 p->p_memsz = DEFAULT_STACK_SIZE;
4216
4217 p->p_align = 8;
4218 }
4219
4220 return TRUE;
4221 }
4222
4223 static bfd_boolean
4224 elf32_bfinfdpic_finish_dynamic_sections (bfd *output_bfd,
4225 struct bfd_link_info *info)
4226 {
4227 bfd *dynobj;
4228 asection *sdyn;
4229
4230 dynobj = elf_hash_table (info)->dynobj;
4231
4232 if (bfinfdpic_got_section (info))
4233 {
4234 BFD_ASSERT (bfinfdpic_gotrel_section (info)->size
4235 == (bfinfdpic_gotrel_section (info)->reloc_count
4236 * sizeof (Elf32_External_Rel)));
4237
4238 if (bfinfdpic_gotfixup_section (info))
4239 {
4240 struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
4241 bfd_vma got_value = hgot->root.u.def.value
4242 + hgot->root.u.def.section->output_section->vma
4243 + hgot->root.u.def.section->output_offset;
4244
4245 _bfinfdpic_add_rofixup (output_bfd, bfinfdpic_gotfixup_section (info),
4246 got_value, 0);
4247
4248 if (bfinfdpic_gotfixup_section (info)->size
4249 != (bfinfdpic_gotfixup_section (info)->reloc_count * 4))
4250 {
4251 (*_bfd_error_handler)
4252 ("LINKER BUG: .rofixup section size mismatch");
4253 return FALSE;
4254 }
4255 }
4256 }
4257 if (elf_hash_table (info)->dynamic_sections_created)
4258 {
4259 BFD_ASSERT (bfinfdpic_pltrel_section (info)->size
4260 == (bfinfdpic_pltrel_section (info)->reloc_count
4261 * sizeof (Elf32_External_Rel)));
4262 }
4263
4264 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4265
4266 if (elf_hash_table (info)->dynamic_sections_created)
4267 {
4268 Elf32_External_Dyn * dyncon;
4269 Elf32_External_Dyn * dynconend;
4270
4271 BFD_ASSERT (sdyn != NULL);
4272
4273 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4274 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4275
4276 for (; dyncon < dynconend; dyncon++)
4277 {
4278 Elf_Internal_Dyn dyn;
4279
4280 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4281
4282 switch (dyn.d_tag)
4283 {
4284 default:
4285 break;
4286
4287 case DT_PLTGOT:
4288 dyn.d_un.d_ptr = bfinfdpic_got_section (info)->output_section->vma
4289 + bfinfdpic_got_section (info)->output_offset
4290 + bfinfdpic_got_initial_offset (info);
4291 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4292 break;
4293
4294 case DT_JMPREL:
4295 dyn.d_un.d_ptr = bfinfdpic_pltrel_section (info)
4296 ->output_section->vma
4297 + bfinfdpic_pltrel_section (info)->output_offset;
4298 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4299 break;
4300
4301 case DT_PLTRELSZ:
4302 dyn.d_un.d_val = bfinfdpic_pltrel_section (info)->size;
4303 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4304 break;
4305 }
4306 }
4307 }
4308
4309 return TRUE;
4310 }
4311
4312 /* Adjust a symbol defined by a dynamic object and referenced by a
4313 regular object. */
4314
4315 static bfd_boolean
4316 elf32_bfinfdpic_adjust_dynamic_symbol
4317 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
4318 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4319 {
4320 bfd * dynobj;
4321
4322 dynobj = elf_hash_table (info)->dynobj;
4323
4324 /* Make sure we know what is going on here. */
4325 BFD_ASSERT (dynobj != NULL
4326 && (h->u.weakdef != NULL
4327 || (h->def_dynamic
4328 && h->ref_regular
4329 && !h->def_regular)));
4330
4331 /* If this is a weak symbol, and there is a real definition, the
4332 processor independent code will have arranged for us to see the
4333 real definition first, and we can just use the same value. */
4334 if (h->u.weakdef != NULL)
4335 {
4336 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4337 || h->u.weakdef->root.type == bfd_link_hash_defweak);
4338 h->root.u.def.section = h->u.weakdef->root.u.def.section;
4339 h->root.u.def.value = h->u.weakdef->root.u.def.value;
4340 }
4341
4342 return TRUE;
4343 }
4344
4345 /* Perform any actions needed for dynamic symbols. */
4346
4347 static bfd_boolean
4348 elf32_bfinfdpic_finish_dynamic_symbol
4349 (bfd *output_bfd ATTRIBUTE_UNUSED,
4350 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4351 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
4352 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
4353 {
4354 return TRUE;
4355 }
4356
4357 /* Decide whether to attempt to turn absptr or lsda encodings in
4358 shared libraries into pcrel within the given input section. */
4359
4360 static bfd_boolean
4361 bfinfdpic_elf_use_relative_eh_frame
4362 (bfd *input_bfd ATTRIBUTE_UNUSED,
4363 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4364 asection *eh_frame_section ATTRIBUTE_UNUSED)
4365 {
4366 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
4367 return FALSE;
4368 }
4369
4370 /* Adjust the contents of an eh_frame_hdr section before they're output. */
4371
4372 static bfd_byte
4373 bfinfdpic_elf_encode_eh_address (bfd *abfd,
4374 struct bfd_link_info *info,
4375 asection *osec, bfd_vma offset,
4376 asection *loc_sec, bfd_vma loc_offset,
4377 bfd_vma *encoded)
4378 {
4379 struct elf_link_hash_entry *h;
4380
4381 h = elf_hash_table (info)->hgot;
4382 BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
4383
4384 if (! h || (_bfinfdpic_osec_to_segment (abfd, osec)
4385 == _bfinfdpic_osec_to_segment (abfd, loc_sec->output_section)))
4386 return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
4387 loc_sec, loc_offset, encoded);
4388
4389 BFD_ASSERT (_bfinfdpic_osec_to_segment (abfd, osec)
4390 == (_bfinfdpic_osec_to_segment
4391 (abfd, h->root.u.def.section->output_section)));
4392
4393 *encoded = osec->vma + offset
4394 - (h->root.u.def.value
4395 + h->root.u.def.section->output_section->vma
4396 + h->root.u.def.section->output_offset);
4397
4398 return DW_EH_PE_datarel | DW_EH_PE_sdata4;
4399 }
4400
4401
4402
4403 /* Look through the relocs for a section during the first phase.
4404
4405 Besides handling virtual table relocs for gc, we have to deal with
4406 all sorts of PIC-related relocations. We describe below the
4407 general plan on how to handle such relocations, even though we only
4408 collect information at this point, storing them in hash tables for
4409 perusal of later passes.
4410
4411 32 relocations are propagated to the linker output when creating
4412 position-independent output. LO16 and HI16 relocations are not
4413 supposed to be encountered in this case.
4414
4415 LABEL16 should always be resolvable by the linker, since it's only
4416 used by branches.
4417
4418 LABEL24, on the other hand, is used by calls. If it turns out that
4419 the target of a call is a dynamic symbol, a PLT entry must be
4420 created for it, which triggers the creation of a private function
4421 descriptor and, unless lazy binding is disabled, a lazy PLT entry.
4422
4423 GPREL relocations require the referenced symbol to be in the same
4424 segment as _gp, but this can only be checked later.
4425
4426 All GOT, GOTOFF and FUNCDESC relocations require a .got section to
4427 exist. LABEL24 might as well, since it may require a PLT entry,
4428 that will require a got.
4429
4430 Non-FUNCDESC GOT relocations require a GOT entry to be created
4431 regardless of whether the symbol is dynamic. However, since a
4432 global symbol that turns out to not be exported may have the same
4433 address of a non-dynamic symbol, we don't assign GOT entries at
4434 this point, such that we can share them in this case. A relocation
4435 for the GOT entry always has to be created, be it to offset a
4436 private symbol by the section load address, be it to get the symbol
4437 resolved dynamically.
4438
4439 FUNCDESC GOT relocations require a GOT entry to be created, and
4440 handled as if a FUNCDESC relocation was applied to the GOT entry in
4441 an object file.
4442
4443 FUNCDESC relocations referencing a symbol that turns out to NOT be
4444 dynamic cause a private function descriptor to be created. The
4445 FUNCDESC relocation then decays to a 32 relocation that points at
4446 the private descriptor. If the symbol is dynamic, the FUNCDESC
4447 relocation is propagated to the linker output, such that the
4448 dynamic linker creates the canonical descriptor, pointing to the
4449 dynamically-resolved definition of the function.
4450
4451 Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
4452 symbols that are assigned to the same segment as the GOT, but we
4453 can only check this later, after we know the complete set of
4454 symbols defined and/or exported.
4455
4456 FUNCDESC GOTOFF relocations require a function descriptor to be
4457 created and, unless lazy binding is disabled or the symbol is not
4458 dynamic, a lazy PLT entry. Since we can't tell at this point
4459 whether a symbol is going to be dynamic, we have to decide later
4460 whether to create a lazy PLT entry or bind the descriptor directly
4461 to the private function.
4462
4463 FUNCDESC_VALUE relocations are not supposed to be present in object
4464 files, but they may very well be simply propagated to the linker
4465 output, since they have no side effect.
4466
4467
4468 A function descriptor always requires a FUNCDESC_VALUE relocation.
4469 Whether it's in .plt.rel or not depends on whether lazy binding is
4470 enabled and on whether the referenced symbol is dynamic.
4471
4472 The existence of a lazy PLT requires the resolverStub lazy PLT
4473 entry to be present.
4474
4475
4476 As for assignment of GOT, PLT and lazy PLT entries, and private
4477 descriptors, we might do them all sequentially, but we can do
4478 better than that. For example, we can place GOT entries and
4479 private function descriptors referenced using 12-bit operands
4480 closer to the PIC register value, such that these relocations don't
4481 overflow. Those that are only referenced with LO16 relocations
4482 could come next, but we may as well place PLT-required function
4483 descriptors in the 12-bit range to make them shorter. Symbols
4484 referenced with LO16/HI16 may come next, but we may place
4485 additional function descriptors in the 16-bit range if we can
4486 reliably tell that we've already placed entries that are ever
4487 referenced with only LO16. PLT entries are therefore generated as
4488 small as possible, while not introducing relocation overflows in
4489 GOT or FUNCDESC_GOTOFF relocations. Lazy PLT entries could be
4490 generated before or after PLT entries, but not intermingled with
4491 them, such that we can have more lazy PLT entries in range for a
4492 branch to the resolverStub. The resolverStub should be emitted at
4493 the most distant location from the first lazy PLT entry such that
4494 it's still in range for a branch, or closer, if there isn't a need
4495 for so many lazy PLT entries. Additional lazy PLT entries may be
4496 emitted after the resolverStub, as long as branches are still in
4497 range. If the branch goes out of range, longer lazy PLT entries
4498 are emitted.
4499
4500 We could further optimize PLT and lazy PLT entries by giving them
4501 priority in assignment to closer-to-gr17 locations depending on the
4502 number of occurrences of references to them (assuming a function
4503 that's called more often is more important for performance, so its
4504 PLT entry should be faster), or taking hints from the compiler.
4505 Given infinite time and money... :-) */
4506
4507 static bfd_boolean
4508 bfinfdpic_check_relocs (bfd *abfd, struct bfd_link_info *info,
4509 asection *sec, const Elf_Internal_Rela *relocs)
4510 {
4511 Elf_Internal_Shdr *symtab_hdr;
4512 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4513 const Elf_Internal_Rela *rel;
4514 const Elf_Internal_Rela *rel_end;
4515 bfd *dynobj;
4516 struct bfinfdpic_relocs_info *picrel;
4517
4518 if (info->relocatable)
4519 return TRUE;
4520
4521 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4522 sym_hashes = elf_sym_hashes (abfd);
4523 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
4524 if (!elf_bad_symtab (abfd))
4525 sym_hashes_end -= symtab_hdr->sh_info;
4526
4527 dynobj = elf_hash_table (info)->dynobj;
4528 rel_end = relocs + sec->reloc_count;
4529 for (rel = relocs; rel < rel_end; rel++)
4530 {
4531 struct elf_link_hash_entry *h;
4532 unsigned long r_symndx;
4533
4534 r_symndx = ELF32_R_SYM (rel->r_info);
4535 if (r_symndx < symtab_hdr->sh_info)
4536 h = NULL;
4537 else
4538 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4539
4540 switch (ELF32_R_TYPE (rel->r_info))
4541 {
4542 case R_BFIN_GOT17M4:
4543 case R_BFIN_GOTHI:
4544 case R_BFIN_GOTLO:
4545 case R_BFIN_FUNCDESC_GOT17M4:
4546 case R_BFIN_FUNCDESC_GOTHI:
4547 case R_BFIN_FUNCDESC_GOTLO:
4548 case R_BFIN_GOTOFF17M4:
4549 case R_BFIN_GOTOFFHI:
4550 case R_BFIN_GOTOFFLO:
4551 case R_BFIN_FUNCDESC_GOTOFF17M4:
4552 case R_BFIN_FUNCDESC_GOTOFFHI:
4553 case R_BFIN_FUNCDESC_GOTOFFLO:
4554 case R_BFIN_FUNCDESC:
4555 case R_BFIN_FUNCDESC_VALUE:
4556 if (! IS_FDPIC (abfd))
4557 goto bad_reloc;
4558 /* Fall through. */
4559 case R_pcrel24:
4560 case R_pcrel24_jump_l:
4561 case R_byte4_data:
4562 if (IS_FDPIC (abfd) && ! dynobj)
4563 {
4564 elf_hash_table (info)->dynobj = dynobj = abfd;
4565 if (! _bfin_create_got_section (abfd, info))
4566 return FALSE;
4567 }
4568 if (! IS_FDPIC (abfd))
4569 {
4570 picrel = NULL;
4571 break;
4572 }
4573 if (h != NULL)
4574 {
4575 if (h->dynindx == -1)
4576 switch (ELF_ST_VISIBILITY (h->other))
4577 {
4578 case STV_INTERNAL:
4579 case STV_HIDDEN:
4580 break;
4581 default:
4582 bfd_elf_link_record_dynamic_symbol (info, h);
4583 break;
4584 }
4585 picrel
4586 = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info),
4587 abfd, h,
4588 rel->r_addend, INSERT);
4589 }
4590 else
4591 picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
4592 (info), abfd, r_symndx,
4593 rel->r_addend, INSERT);
4594 if (! picrel)
4595 return FALSE;
4596 break;
4597
4598 default:
4599 picrel = NULL;
4600 break;
4601 }
4602
4603 switch (ELF32_R_TYPE (rel->r_info))
4604 {
4605 case R_pcrel24:
4606 case R_pcrel24_jump_l:
4607 if (IS_FDPIC (abfd))
4608 picrel->call = 1;
4609 break;
4610
4611 case R_BFIN_FUNCDESC_VALUE:
4612 picrel->relocsfdv++;
4613 if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
4614 picrel->relocs32--;
4615 /* Fall through. */
4616
4617 case R_byte4_data:
4618 if (! IS_FDPIC (abfd))
4619 break;
4620
4621 picrel->sym = 1;
4622 if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
4623 picrel->relocs32++;
4624 break;
4625
4626 case R_BFIN_GOT17M4:
4627 picrel->got17m4 = 1;
4628 break;
4629
4630 case R_BFIN_GOTHI:
4631 case R_BFIN_GOTLO:
4632 picrel->gothilo = 1;
4633 break;
4634
4635 case R_BFIN_FUNCDESC_GOT17M4:
4636 picrel->fdgot17m4 = 1;
4637 break;
4638
4639 case R_BFIN_FUNCDESC_GOTHI:
4640 case R_BFIN_FUNCDESC_GOTLO:
4641 picrel->fdgothilo = 1;
4642 break;
4643
4644 case R_BFIN_GOTOFF17M4:
4645 case R_BFIN_GOTOFFHI:
4646 case R_BFIN_GOTOFFLO:
4647 picrel->gotoff = 1;
4648 break;
4649
4650 case R_BFIN_FUNCDESC_GOTOFF17M4:
4651 picrel->fdgoff17m4 = 1;
4652 break;
4653
4654 case R_BFIN_FUNCDESC_GOTOFFHI:
4655 case R_BFIN_FUNCDESC_GOTOFFLO:
4656 picrel->fdgoffhilo = 1;
4657 break;
4658
4659 case R_BFIN_FUNCDESC:
4660 picrel->fd = 1;
4661 picrel->relocsfd++;
4662 break;
4663
4664 /* This relocation describes the C++ object vtable hierarchy.
4665 Reconstruct it for later use during GC. */
4666 case R_BFIN_GNU_VTINHERIT:
4667 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4668 return FALSE;
4669 break;
4670
4671 /* This relocation describes which C++ vtable entries are actually
4672 used. Record for later use during GC. */
4673 case R_BFIN_GNU_VTENTRY:
4674 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4675 return FALSE;
4676 break;
4677
4678 case R_huimm16:
4679 case R_luimm16:
4680 case R_pcrel12_jump_s:
4681 case R_pcrel10:
4682 break;
4683
4684 default:
4685 bad_reloc:
4686 (*_bfd_error_handler)
4687 (_("%B: unsupported relocation type %i"),
4688 abfd, ELF32_R_TYPE (rel->r_info));
4689 return FALSE;
4690 }
4691 }
4692
4693 return TRUE;
4694 }
4695
4696 /* Set the right machine number for a Blackfin ELF file. */
4697
4698 static bfd_boolean
4699 elf32_bfin_object_p (bfd *abfd)
4700 {
4701 bfd_default_set_arch_mach (abfd, bfd_arch_bfin, 0);
4702 return (((elf_elfheader (abfd)->e_flags & EF_BFIN_FDPIC) != 0)
4703 == (IS_FDPIC (abfd)));
4704 }
4705
4706 static bfd_boolean
4707 elf32_bfin_set_private_flags (bfd * abfd, flagword flags)
4708 {
4709 elf_elfheader (abfd)->e_flags = flags;
4710 elf_flags_init (abfd) = TRUE;
4711 return TRUE;
4712 }
4713
4714 /* Copy backend specific data from one object module to another. */
4715
4716 static bfd_boolean
4717 bfin_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4718 {
4719 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4720 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4721 return TRUE;
4722
4723 BFD_ASSERT (!elf_flags_init (obfd)
4724 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
4725
4726 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
4727 elf_flags_init (obfd) = TRUE;
4728 return TRUE;
4729 }
4730
4731 static bfd_boolean
4732 elf32_bfinfdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4733 {
4734 unsigned i;
4735
4736 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4737 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4738 return TRUE;
4739
4740 if (! bfin_elf_copy_private_bfd_data (ibfd, obfd))
4741 return FALSE;
4742
4743 if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
4744 || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
4745 return TRUE;
4746
4747 /* Copy the stack size. */
4748 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
4749 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
4750 {
4751 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
4752
4753 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
4754 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
4755 {
4756 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
4757
4758 /* Rewrite the phdrs, since we're only called after they
4759 were first written. */
4760 if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
4761 ->s->sizeof_ehdr, SEEK_SET) != 0
4762 || get_elf_backend_data (obfd)->s
4763 ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
4764 elf_elfheader (obfd)->e_phnum) != 0)
4765 return FALSE;
4766 break;
4767 }
4768
4769 break;
4770 }
4771
4772 return TRUE;
4773 }
4774
4775
4776 /* Display the flags field. */
4777 static bfd_boolean
4778 elf32_bfin_print_private_bfd_data (bfd * abfd, PTR ptr)
4779 {
4780 FILE *file = (FILE *) ptr;
4781 flagword flags;
4782
4783 BFD_ASSERT (abfd != NULL && ptr != NULL);
4784
4785 /* Print normal ELF private data. */
4786 _bfd_elf_print_private_bfd_data (abfd, ptr);
4787
4788 flags = elf_elfheader (abfd)->e_flags;
4789
4790 /* xgettext:c-format */
4791 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
4792
4793 if (flags & EF_BFIN_PIC)
4794 fprintf (file, " -fpic");
4795
4796 if (flags & EF_BFIN_FDPIC)
4797 fprintf (file, " -mfdpic");
4798
4799 fputc ('\n', file);
4800
4801 return TRUE;
4802 }
4803
4804 /* Merge backend specific data from an object file to the output
4805 object file when linking. */
4806
4807 static bfd_boolean
4808 elf32_bfin_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4809 {
4810 flagword old_flags, old_partial;
4811 flagword new_flags, new_partial;
4812 bfd_boolean error = FALSE;
4813
4814 new_flags = elf_elfheader (ibfd)->e_flags;
4815 old_flags = elf_elfheader (obfd)->e_flags;
4816
4817 if (new_flags & EF_BFIN_FDPIC)
4818 new_flags &= ~EF_BFIN_PIC;
4819
4820 #ifdef DEBUG
4821 (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
4822 old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
4823 bfd_get_filename (ibfd));
4824 #endif
4825
4826 if (!elf_flags_init (obfd)) /* First call, no flags set. */
4827 {
4828 elf_flags_init (obfd) = TRUE;
4829 old_flags = new_flags;
4830 }
4831
4832 else if (new_flags == old_flags) /* Compatible flags are ok. */
4833 ;
4834
4835 else /* Possibly incompatible flags. */
4836 {
4837 /* We don't have to do anything if the pic flags are the same, or the new
4838 module(s) were compiled with -mlibrary-pic. */
4839 new_partial = (new_flags & EF_BFIN_PIC_FLAGS);
4840 old_partial = (old_flags & EF_BFIN_PIC_FLAGS);
4841 if (new_partial == old_partial)
4842 ;
4843
4844 /* If we have mixtures of -fpic and -fPIC, or in both bits. */
4845 else if (new_partial != 0 && old_partial != 0)
4846 old_flags |= new_partial;
4847
4848 /* One module was compiled for pic and the other was not, see if we have
4849 had any relocations that are not pic-safe. */
4850 else
4851 old_flags |= new_partial;
4852
4853 }
4854
4855 /* Update the old flags now with changes made above. */
4856 elf_elfheader (obfd)->e_flags = old_flags;
4857
4858 if (((new_flags & EF_BFIN_FDPIC) == 0)
4859 != (! IS_FDPIC (ibfd)))
4860 {
4861 error = TRUE;
4862 if (IS_FDPIC (obfd))
4863 (*_bfd_error_handler)
4864 (_("%s: cannot link non-fdpic object file into fdpic executable"),
4865 bfd_get_filename (ibfd));
4866 else
4867 (*_bfd_error_handler)
4868 (_("%s: cannot link fdpic object file into non-fdpic executable"),
4869 bfd_get_filename (ibfd));
4870 }
4871
4872 if (error)
4873 bfd_set_error (bfd_error_bad_value);
4874
4875 return !error;
4876 }
4877 \f
4878 /* bfin ELF linker hash entry. */
4879
4880 struct bfin_link_hash_entry
4881 {
4882 struct elf_link_hash_entry root;
4883
4884 /* Number of PC relative relocs copied for this symbol. */
4885 struct bfin_pcrel_relocs_copied *pcrel_relocs_copied;
4886 };
4887
4888 /* bfin ELF linker hash table. */
4889
4890 struct bfin_link_hash_table
4891 {
4892 struct elf_link_hash_table root;
4893
4894 /* Small local sym to section mapping cache. */
4895 struct sym_sec_cache sym_sec;
4896 };
4897
4898 #define bfin_hash_entry(ent) ((struct bfin_link_hash_entry *) (ent))
4899
4900 static struct bfd_hash_entry *
4901 bfin_link_hash_newfunc (struct bfd_hash_entry *entry,
4902 struct bfd_hash_table *table, const char *string)
4903 {
4904 struct bfd_hash_entry *ret = entry;
4905
4906 /* Allocate the structure if it has not already been allocated by a
4907 subclass. */
4908 if (ret == NULL)
4909 ret = bfd_hash_allocate (table, sizeof (struct bfin_link_hash_entry));
4910 if (ret == NULL)
4911 return ret;
4912
4913 /* Call the allocation method of the superclass. */
4914 ret = _bfd_elf_link_hash_newfunc (ret, table, string);
4915 if (ret != NULL)
4916 bfin_hash_entry (ret)->pcrel_relocs_copied = NULL;
4917
4918 return ret;
4919 }
4920
4921 /* Create an bfin ELF linker hash table. */
4922
4923 static struct bfd_link_hash_table *
4924 bfin_link_hash_table_create (bfd * abfd)
4925 {
4926 struct bfin_link_hash_table *ret;
4927 bfd_size_type amt = sizeof (struct bfin_link_hash_table);
4928
4929 ret = bfd_zalloc (abfd, amt);
4930 if (ret == NULL)
4931 return NULL;
4932
4933 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
4934 bfin_link_hash_newfunc,
4935 sizeof (struct elf_link_hash_entry)))
4936 {
4937 free (ret);
4938 return NULL;
4939 }
4940
4941 ret->sym_sec.abfd = NULL;
4942
4943 return &ret->root.root;
4944 }
4945
4946 /* The size in bytes of an entry in the procedure linkage table. */
4947
4948 /* Finish up the dynamic sections. */
4949
4950 static bfd_boolean
4951 bfin_finish_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
4952 struct bfd_link_info *info)
4953 {
4954 bfd *dynobj;
4955 asection *sdyn;
4956
4957 dynobj = elf_hash_table (info)->dynobj;
4958
4959 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4960
4961 if (elf_hash_table (info)->dynamic_sections_created)
4962 {
4963 Elf32_External_Dyn *dyncon, *dynconend;
4964
4965 BFD_ASSERT (sdyn != NULL);
4966
4967 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4968 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4969 for (; dyncon < dynconend; dyncon++)
4970 {
4971 Elf_Internal_Dyn dyn;
4972
4973 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4974
4975 }
4976
4977 }
4978 return TRUE;
4979 }
4980
4981 /* Finish up dynamic symbol handling. We set the contents of various
4982 dynamic sections here. */
4983
4984 static bfd_boolean
4985 bfin_finish_dynamic_symbol (bfd * output_bfd,
4986 struct bfd_link_info *info,
4987 struct elf_link_hash_entry *h,
4988 Elf_Internal_Sym * sym)
4989 {
4990 bfd *dynobj;
4991
4992 dynobj = elf_hash_table (info)->dynobj;
4993
4994 if (h->got.offset != (bfd_vma) - 1)
4995 {
4996 asection *sgot;
4997 asection *srela;
4998 Elf_Internal_Rela rela;
4999 bfd_byte *loc;
5000
5001 /* This symbol has an entry in the global offset table.
5002 Set it up. */
5003
5004 sgot = bfd_get_section_by_name (dynobj, ".got");
5005 srela = bfd_get_section_by_name (dynobj, ".rela.got");
5006 BFD_ASSERT (sgot != NULL && srela != NULL);
5007
5008 rela.r_offset = (sgot->output_section->vma
5009 + sgot->output_offset
5010 + (h->got.offset & ~(bfd_vma) 1));
5011
5012 /* If this is a -Bsymbolic link, and the symbol is defined
5013 locally, we just want to emit a RELATIVE reloc. Likewise if
5014 the symbol was forced to be local because of a version file.
5015 The entry in the global offset table will already have been
5016 initialized in the relocate_section function. */
5017 if (info->shared
5018 && (info->symbolic
5019 || h->dynindx == -1 || h->forced_local) && h->def_regular)
5020 {
5021 fprintf(stderr, "*** check this relocation %s\n", __FUNCTION__);
5022 rela.r_info = ELF32_R_INFO (0, R_pcrel24);
5023 rela.r_addend = bfd_get_signed_32 (output_bfd,
5024 (sgot->contents
5025 +
5026 (h->got.
5027 offset & ~(bfd_vma) 1)));
5028 }
5029 else
5030 {
5031 bfd_put_32 (output_bfd, (bfd_vma) 0,
5032 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
5033 rela.r_info = ELF32_R_INFO (h->dynindx, R_got);
5034 rela.r_addend = 0;
5035 }
5036
5037 loc = srela->contents;
5038 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
5039 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5040 }
5041
5042 if (h->needs_copy)
5043 {
5044 BFD_ASSERT (0);
5045 }
5046 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
5047 if (strcmp (h->root.root.string, "__DYNAMIC") == 0
5048 || h == elf_hash_table (info)->hgot)
5049 sym->st_shndx = SHN_ABS;
5050
5051 return TRUE;
5052 }
5053
5054 /* Adjust a symbol defined by a dynamic object and referenced by a
5055 regular object. The current definition is in some section of the
5056 dynamic object, but we're not including those sections. We have to
5057 change the definition to something the rest of the link can
5058 understand. */
5059
5060 static bfd_boolean
5061 bfin_adjust_dynamic_symbol (struct bfd_link_info *info,
5062 struct elf_link_hash_entry *h)
5063 {
5064 bfd *dynobj;
5065 asection *s;
5066 unsigned int power_of_two;
5067
5068 dynobj = elf_hash_table (info)->dynobj;
5069
5070 /* Make sure we know what is going on here. */
5071 BFD_ASSERT (dynobj != NULL
5072 && (h->needs_plt
5073 || h->u.weakdef != NULL
5074 || (h->def_dynamic && h->ref_regular && !h->def_regular)));
5075
5076 /* If this is a function, put it in the procedure linkage table. We
5077 will fill in the contents of the procedure linkage table later,
5078 when we know the address of the .got section. */
5079 if (h->type == STT_FUNC || h->needs_plt)
5080 {
5081 BFD_ASSERT(0);
5082 }
5083
5084 /* If this is a weak symbol, and there is a real definition, the
5085 processor independent code will have arranged for us to see the
5086 real definition first, and we can just use the same value. */
5087 if (h->u.weakdef != NULL)
5088 {
5089 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5090 || h->u.weakdef->root.type == bfd_link_hash_defweak);
5091 h->root.u.def.section = h->u.weakdef->root.u.def.section;
5092 h->root.u.def.value = h->u.weakdef->root.u.def.value;
5093 return TRUE;
5094 }
5095
5096 /* This is a reference to a symbol defined by a dynamic object which
5097 is not a function. */
5098
5099 /* If we are creating a shared library, we must presume that the
5100 only references to the symbol are via the global offset table.
5101 For such cases we need not do anything here; the relocations will
5102 be handled correctly by relocate_section. */
5103 if (info->shared)
5104 return TRUE;
5105
5106 /* We must allocate the symbol in our .dynbss section, which will
5107 become part of the .bss section of the executable. There will be
5108 an entry for this symbol in the .dynsym section. The dynamic
5109 object will contain position independent code, so all references
5110 from the dynamic object to this symbol will go through the global
5111 offset table. The dynamic linker will use the .dynsym entry to
5112 determine the address it must put in the global offset table, so
5113 both the dynamic object and the regular object will refer to the
5114 same memory location for the variable. */
5115
5116 s = bfd_get_section_by_name (dynobj, ".dynbss");
5117 BFD_ASSERT (s != NULL);
5118
5119 /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
5120 copy the initial value out of the dynamic object and into the
5121 runtime process image. We need to remember the offset into the
5122 .rela.bss section we are going to use. */
5123 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5124 {
5125 asection *srel;
5126
5127 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
5128 BFD_ASSERT (srel != NULL);
5129 srel->size += sizeof (Elf32_External_Rela);
5130 h->needs_copy = 1;
5131 }
5132
5133 /* We need to figure out the alignment required for this symbol. I
5134 have no idea how ELF linkers handle this. */
5135 power_of_two = bfd_log2 (h->size);
5136 if (power_of_two > 3)
5137 power_of_two = 3;
5138
5139 /* Apply the required alignment. */
5140 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
5141 if (power_of_two > bfd_get_section_alignment (dynobj, s))
5142 {
5143 if (!bfd_set_section_alignment (dynobj, s, power_of_two))
5144 return FALSE;
5145 }
5146
5147 /* Define the symbol as being at this point in the section. */
5148 h->root.u.def.section = s;
5149 h->root.u.def.value = s->size;
5150
5151 /* Increment the section size to make room for the symbol. */
5152 s->size += h->size;
5153
5154 return TRUE;
5155 }
5156
5157 /* The bfin linker needs to keep track of the number of relocs that it
5158 decides to copy in check_relocs for each symbol. This is so that it
5159 can discard PC relative relocs if it doesn't need them when linking
5160 with -Bsymbolic. We store the information in a field extending the
5161 regular ELF linker hash table. */
5162
5163 /* This structure keeps track of the number of PC relative relocs we have
5164 copied for a given symbol. */
5165
5166 struct bfin_pcrel_relocs_copied
5167 {
5168 /* Next section. */
5169 struct bfin_pcrel_relocs_copied *next;
5170 /* A section in dynobj. */
5171 asection *section;
5172 /* Number of relocs copied in this section. */
5173 bfd_size_type count;
5174 };
5175
5176 /* This function is called via elf_link_hash_traverse if we are
5177 creating a shared object. In the -Bsymbolic case it discards the
5178 space allocated to copy PC relative relocs against symbols which
5179 are defined in regular objects. For the normal shared case, it
5180 discards space for pc-relative relocs that have become local due to
5181 symbol visibility changes. We allocated space for them in the
5182 check_relocs routine, but we won't fill them in in the
5183 relocate_section routine.
5184
5185 We also check whether any of the remaining relocations apply
5186 against a readonly section, and set the DF_TEXTREL flag in this
5187 case. */
5188
5189 static bfd_boolean
5190 bfin_discard_copies (struct elf_link_hash_entry *h, PTR inf)
5191 {
5192 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5193 struct bfin_pcrel_relocs_copied *s;
5194
5195 if (h->root.type == bfd_link_hash_warning)
5196 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5197
5198 if (!h->def_regular || (!info->symbolic && !h->forced_local))
5199 {
5200 if ((info->flags & DF_TEXTREL) == 0)
5201 {
5202 /* Look for relocations against read-only sections. */
5203 for (s = bfin_hash_entry (h)->pcrel_relocs_copied;
5204 s != NULL; s = s->next)
5205 if ((s->section->flags & SEC_READONLY) != 0)
5206 {
5207 info->flags |= DF_TEXTREL;
5208 break;
5209 }
5210 }
5211
5212 return TRUE;
5213 }
5214
5215 for (s = bfin_hash_entry (h)->pcrel_relocs_copied;
5216 s != NULL; s = s->next)
5217 s->section->size -= s->count * sizeof (Elf32_External_Rela);
5218
5219 return TRUE;
5220 }
5221
5222 static bfd_boolean
5223 bfin_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
5224 struct bfd_link_info *info)
5225 {
5226 bfd *dynobj;
5227 asection *s;
5228 bfd_boolean relocs;
5229
5230 dynobj = elf_hash_table (info)->dynobj;
5231 BFD_ASSERT (dynobj != NULL);
5232
5233 if (elf_hash_table (info)->dynamic_sections_created)
5234 {
5235 /* Set the contents of the .interp section to the interpreter. */
5236 if (info->executable)
5237 {
5238 s = bfd_get_section_by_name (dynobj, ".interp");
5239 BFD_ASSERT (s != NULL);
5240 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5241 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5242 }
5243 }
5244 else
5245 {
5246 /* We may have created entries in the .rela.got section.
5247 However, if we are not creating the dynamic sections, we will
5248 not actually use these entries. Reset the size of .rela.got,
5249 which will cause it to get stripped from the output file
5250 below. */
5251 s = bfd_get_section_by_name (dynobj, ".rela.got");
5252 if (s != NULL)
5253 s->size = 0;
5254 }
5255
5256 /* If this is a -Bsymbolic shared link, then we need to discard all
5257 PC relative relocs against symbols defined in a regular object.
5258 For the normal shared case we discard the PC relative relocs
5259 against symbols that have become local due to visibility changes.
5260 We allocated space for them in the check_relocs routine, but we
5261 will not fill them in in the relocate_section routine. */
5262 if (info->shared)
5263 elf_link_hash_traverse (elf_hash_table (info),
5264 bfin_discard_copies, (PTR) info);
5265
5266 /* The check_relocs and adjust_dynamic_symbol entry points have
5267 determined the sizes of the various dynamic sections. Allocate
5268 memory for them. */
5269 relocs = FALSE;
5270 for (s = dynobj->sections; s != NULL; s = s->next)
5271 {
5272 const char *name;
5273 bfd_boolean strip;
5274
5275 if ((s->flags & SEC_LINKER_CREATED) == 0)
5276 continue;
5277
5278 /* It's OK to base decisions on the section name, because none
5279 of the dynobj section names depend upon the input files. */
5280 name = bfd_get_section_name (dynobj, s);
5281
5282 strip = FALSE;
5283
5284 if (CONST_STRNEQ (name, ".rela"))
5285 {
5286 if (s->size == 0)
5287 {
5288 /* If we don't need this section, strip it from the
5289 output file. This is mostly to handle .rela.bss and
5290 .rela.plt. We must create both sections in
5291 create_dynamic_sections, because they must be created
5292 before the linker maps input sections to output
5293 sections. The linker does that before
5294 adjust_dynamic_symbol is called, and it is that
5295 function which decides whether anything needs to go
5296 into these sections. */
5297 strip = TRUE;
5298 }
5299 else
5300 {
5301 relocs = TRUE;
5302
5303 /* We use the reloc_count field as a counter if we need
5304 to copy relocs into the output file. */
5305 s->reloc_count = 0;
5306 }
5307 }
5308 else if (! CONST_STRNEQ (name, ".got"))
5309 {
5310 /* It's not one of our sections, so don't allocate space. */
5311 continue;
5312 }
5313
5314 if (strip)
5315 {
5316 s->flags |= SEC_EXCLUDE;
5317 continue;
5318 }
5319
5320 /* Allocate memory for the section contents. */
5321 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
5322 Unused entries should be reclaimed before the section's contents
5323 are written out, but at the moment this does not happen. Thus in
5324 order to prevent writing out garbage, we initialise the section's
5325 contents to zero. */
5326 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
5327 if (s->contents == NULL && s->size != 0)
5328 return FALSE;
5329 }
5330
5331 if (elf_hash_table (info)->dynamic_sections_created)
5332 {
5333 /* Add some entries to the .dynamic section. We fill in the
5334 values later, in bfin_finish_dynamic_sections, but we
5335 must add the entries now so that we get the correct size for
5336 the .dynamic section. The DT_DEBUG entry is filled in by the
5337 dynamic linker and used by the debugger. */
5338 #define add_dynamic_entry(TAG, VAL) \
5339 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5340
5341 if (!info->shared)
5342 {
5343 if (!add_dynamic_entry (DT_DEBUG, 0))
5344 return FALSE;
5345 }
5346
5347
5348 if (relocs)
5349 {
5350 if (!add_dynamic_entry (DT_RELA, 0)
5351 || !add_dynamic_entry (DT_RELASZ, 0)
5352 || !add_dynamic_entry (DT_RELAENT,
5353 sizeof (Elf32_External_Rela)))
5354 return FALSE;
5355 }
5356
5357 if ((info->flags & DF_TEXTREL) != 0)
5358 {
5359 if (!add_dynamic_entry (DT_TEXTREL, 0))
5360 return FALSE;
5361 }
5362 }
5363 #undef add_dynamic_entry
5364
5365 return TRUE;
5366 }
5367 \f
5368 /* Given a .data section and a .emreloc in-memory section, store
5369 relocation information into the .emreloc section which can be
5370 used at runtime to relocate the section. This is called by the
5371 linker when the --embedded-relocs switch is used. This is called
5372 after the add_symbols entry point has been called for all the
5373 objects, and before the final_link entry point is called. */
5374
5375 bfd_boolean bfd_bfin_elf32_create_embedded_relocs
5376 PARAMS ((bfd *, struct bfd_link_info *, asection *, asection *, char **));
5377
5378 bfd_boolean
5379 bfd_bfin_elf32_create_embedded_relocs (
5380 bfd *abfd,
5381 struct bfd_link_info *info,
5382 asection *datasec,
5383 asection *relsec,
5384 char **errmsg)
5385 {
5386 Elf_Internal_Shdr *symtab_hdr;
5387 Elf_Internal_Sym *isymbuf = NULL;
5388 Elf_Internal_Rela *internal_relocs = NULL;
5389 Elf_Internal_Rela *irel, *irelend;
5390 bfd_byte *p;
5391 bfd_size_type amt;
5392
5393 BFD_ASSERT (! info->relocatable);
5394
5395 *errmsg = NULL;
5396
5397 if (datasec->reloc_count == 0)
5398 return TRUE;
5399
5400 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5401
5402 /* Get a copy of the native relocations. */
5403 internal_relocs = (_bfd_elf_link_read_relocs
5404 (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
5405 info->keep_memory));
5406 if (internal_relocs == NULL)
5407 goto error_return;
5408
5409 amt = (bfd_size_type) datasec->reloc_count * 12;
5410 relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
5411 if (relsec->contents == NULL)
5412 goto error_return;
5413
5414 p = relsec->contents;
5415
5416 irelend = internal_relocs + datasec->reloc_count;
5417 for (irel = internal_relocs; irel < irelend; irel++, p += 12)
5418 {
5419 asection *targetsec;
5420
5421 /* We are going to write a four byte longword into the runtime
5422 reloc section. The longword will be the address in the data
5423 section which must be relocated. It is followed by the name
5424 of the target section NUL-padded or truncated to 8
5425 characters. */
5426
5427 /* We can only relocate absolute longword relocs at run time. */
5428 if (ELF32_R_TYPE (irel->r_info) != (int) R_byte4_data)
5429 {
5430 *errmsg = _("unsupported reloc type");
5431 bfd_set_error (bfd_error_bad_value);
5432 goto error_return;
5433 }
5434
5435 /* Get the target section referred to by the reloc. */
5436 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
5437 {
5438 /* A local symbol. */
5439 Elf_Internal_Sym *isym;
5440
5441 /* Read this BFD's local symbols if we haven't done so already. */
5442 if (isymbuf == NULL)
5443 {
5444 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5445 if (isymbuf == NULL)
5446 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
5447 symtab_hdr->sh_info, 0,
5448 NULL, NULL, NULL);
5449 if (isymbuf == NULL)
5450 goto error_return;
5451 }
5452
5453 isym = isymbuf + ELF32_R_SYM (irel->r_info);
5454 targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
5455 }
5456 else
5457 {
5458 unsigned long indx;
5459 struct elf_link_hash_entry *h;
5460
5461 /* An external symbol. */
5462 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
5463 h = elf_sym_hashes (abfd)[indx];
5464 BFD_ASSERT (h != NULL);
5465 if (h->root.type == bfd_link_hash_defined
5466 || h->root.type == bfd_link_hash_defweak)
5467 targetsec = h->root.u.def.section;
5468 else
5469 targetsec = NULL;
5470 }
5471
5472 bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
5473 memset (p + 4, 0, 8);
5474 if (targetsec != NULL)
5475 strncpy ((char *) p + 4, targetsec->output_section->name, 8);
5476 }
5477
5478 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
5479 free (isymbuf);
5480 if (internal_relocs != NULL
5481 && elf_section_data (datasec)->relocs != internal_relocs)
5482 free (internal_relocs);
5483 return TRUE;
5484
5485 error_return:
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 FALSE;
5492 }
5493 \f
5494 #define TARGET_LITTLE_SYM bfd_elf32_bfin_vec
5495 #define TARGET_LITTLE_NAME "elf32-bfin"
5496 #define ELF_ARCH bfd_arch_bfin
5497 #define ELF_MACHINE_CODE EM_BLACKFIN
5498 #define ELF_MAXPAGESIZE 0x1000
5499 #define elf_symbol_leading_char '_'
5500
5501 #define bfd_elf32_bfd_reloc_type_lookup bfin_bfd_reloc_type_lookup
5502 #define bfd_elf32_bfd_reloc_name_lookup \
5503 bfin_bfd_reloc_name_lookup
5504 #define elf_info_to_howto bfin_info_to_howto
5505 #define elf_info_to_howto_rel 0
5506 #define elf_backend_object_p elf32_bfin_object_p
5507
5508 #define bfd_elf32_bfd_is_local_label_name \
5509 bfin_is_local_label_name
5510 #define bfin_hash_table(p) \
5511 ((struct bfin_link_hash_table *) (p)->hash)
5512
5513
5514
5515 #define elf_backend_create_dynamic_sections \
5516 _bfd_elf_create_dynamic_sections
5517 #define bfd_elf32_bfd_link_hash_table_create \
5518 bfin_link_hash_table_create
5519 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link
5520
5521 #define elf_backend_check_relocs bfin_check_relocs
5522 #define elf_backend_adjust_dynamic_symbol \
5523 bfin_adjust_dynamic_symbol
5524 #define elf_backend_size_dynamic_sections \
5525 bfin_size_dynamic_sections
5526 #define elf_backend_relocate_section bfin_relocate_section
5527 #define elf_backend_finish_dynamic_symbol \
5528 bfin_finish_dynamic_symbol
5529 #define elf_backend_finish_dynamic_sections \
5530 bfin_finish_dynamic_sections
5531 #define elf_backend_gc_mark_hook bfin_gc_mark_hook
5532 #define elf_backend_gc_sweep_hook bfin_gc_sweep_hook
5533 #define bfd_elf32_bfd_merge_private_bfd_data \
5534 elf32_bfin_merge_private_bfd_data
5535 #define bfd_elf32_bfd_set_private_flags \
5536 elf32_bfin_set_private_flags
5537 #define bfd_elf32_bfd_print_private_bfd_data \
5538 elf32_bfin_print_private_bfd_data
5539 #define elf_backend_reloc_type_class elf32_bfin_reloc_type_class
5540 #define elf_backend_can_gc_sections 1
5541 #define elf_backend_can_refcount 1
5542 #define elf_backend_want_got_plt 0
5543 #define elf_backend_plt_readonly 1
5544 #define elf_backend_want_plt_sym 0
5545 #define elf_backend_got_header_size 12
5546 #define elf_backend_rela_normal 1
5547
5548 #include "elf32-target.h"
5549
5550 #undef TARGET_LITTLE_SYM
5551 #define TARGET_LITTLE_SYM bfd_elf32_bfinfdpic_vec
5552 #undef TARGET_LITTLE_NAME
5553 #define TARGET_LITTLE_NAME "elf32-bfinfdpic"
5554 #undef elf32_bed
5555 #define elf32_bed elf32_bfinfdpic_bed
5556
5557 #undef elf_backend_gc_sweep_hook
5558
5559 #undef elf_backend_got_header_size
5560 #define elf_backend_got_header_size 0
5561
5562 #undef elf_backend_relocate_section
5563 #define elf_backend_relocate_section bfinfdpic_relocate_section
5564 #undef elf_backend_check_relocs
5565 #define elf_backend_check_relocs bfinfdpic_check_relocs
5566
5567 #undef bfd_elf32_bfd_link_hash_table_create
5568 #define bfd_elf32_bfd_link_hash_table_create \
5569 bfinfdpic_elf_link_hash_table_create
5570 #undef elf_backend_always_size_sections
5571 #define elf_backend_always_size_sections \
5572 elf32_bfinfdpic_always_size_sections
5573 #undef elf_backend_modify_program_headers
5574 #define elf_backend_modify_program_headers \
5575 elf32_bfinfdpic_modify_program_headers
5576 #undef bfd_elf32_bfd_copy_private_bfd_data
5577 #define bfd_elf32_bfd_copy_private_bfd_data \
5578 elf32_bfinfdpic_copy_private_bfd_data
5579
5580 #undef elf_backend_create_dynamic_sections
5581 #define elf_backend_create_dynamic_sections \
5582 elf32_bfinfdpic_create_dynamic_sections
5583 #undef elf_backend_adjust_dynamic_symbol
5584 #define elf_backend_adjust_dynamic_symbol \
5585 elf32_bfinfdpic_adjust_dynamic_symbol
5586 #undef elf_backend_size_dynamic_sections
5587 #define elf_backend_size_dynamic_sections \
5588 elf32_bfinfdpic_size_dynamic_sections
5589 #undef elf_backend_finish_dynamic_symbol
5590 #define elf_backend_finish_dynamic_symbol \
5591 elf32_bfinfdpic_finish_dynamic_symbol
5592 #undef elf_backend_finish_dynamic_sections
5593 #define elf_backend_finish_dynamic_sections \
5594 elf32_bfinfdpic_finish_dynamic_sections
5595
5596 #undef elf_backend_can_make_relative_eh_frame
5597 #define elf_backend_can_make_relative_eh_frame \
5598 bfinfdpic_elf_use_relative_eh_frame
5599 #undef elf_backend_can_make_lsda_relative_eh_frame
5600 #define elf_backend_can_make_lsda_relative_eh_frame \
5601 bfinfdpic_elf_use_relative_eh_frame
5602 #undef elf_backend_encode_eh_address
5603 #define elf_backend_encode_eh_address \
5604 bfinfdpic_elf_encode_eh_address
5605
5606 #undef elf_backend_may_use_rel_p
5607 #define elf_backend_may_use_rel_p 1
5608 #undef elf_backend_may_use_rela_p
5609 #define elf_backend_may_use_rela_p 1
5610 /* We use REL for dynamic relocations only. */
5611 #undef elf_backend_default_use_rela_p
5612 #define elf_backend_default_use_rela_p 1
5613
5614 #undef elf_backend_omit_section_dynsym
5615 #define elf_backend_omit_section_dynsym _bfinfdpic_link_omit_section_dynsym
5616
5617 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.157521 seconds and 5 git commands to generate.