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