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