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