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