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