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