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