elf32-bfin.c revision 1.1.1.8
1 /* ADI Blackfin BFD support for 32-bit ELF. 2 Copyright (C) 2005-2020 Free Software Foundation, Inc. 3 4 This file is part of BFD, the Binary File Descriptor library. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21 #include "sysdep.h" 22 #include "bfd.h" 23 #include "libbfd.h" 24 #include "elf-bfd.h" 25 #include "elf/bfin.h" 26 #include "dwarf2.h" 27 #include "hashtab.h" 28 #include "elf32-bfin.h" 29 30 /* FUNCTION : bfin_pltpc_reloc 31 ABSTRACT : TODO : figure out how to handle pltpc relocs. */ 32 static bfd_reloc_status_type 33 bfin_pltpc_reloc ( 34 bfd *abfd ATTRIBUTE_UNUSED, 35 arelent *reloc_entry ATTRIBUTE_UNUSED, 36 asymbol *symbol ATTRIBUTE_UNUSED, 37 void * data ATTRIBUTE_UNUSED, 38 asection *input_section ATTRIBUTE_UNUSED, 39 bfd *output_bfd ATTRIBUTE_UNUSED, 40 char **error_message ATTRIBUTE_UNUSED) 41 { 42 bfd_reloc_status_type flag = bfd_reloc_ok; 43 return flag; 44 } 45 46 48 static bfd_reloc_status_type 49 bfin_pcrel24_reloc (bfd *abfd, 50 arelent *reloc_entry, 51 asymbol *symbol, 52 void * data, 53 asection *input_section, 54 bfd *output_bfd, 55 char **error_message ATTRIBUTE_UNUSED) 56 { 57 bfd_vma relocation; 58 bfd_size_type addr = reloc_entry->address; 59 bfd_vma output_base = 0; 60 reloc_howto_type *howto = reloc_entry->howto; 61 asection *output_section; 62 bfd_boolean relocatable = (output_bfd != NULL); 63 64 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 65 return bfd_reloc_outofrange; 66 67 if (bfd_is_und_section (symbol->section) 68 && (symbol->flags & BSF_WEAK) == 0 69 && !relocatable) 70 return bfd_reloc_undefined; 71 72 if (bfd_is_com_section (symbol->section)) 73 relocation = 0; 74 else 75 relocation = symbol->value; 76 77 output_section = symbol->section->output_section; 78 79 if (relocatable) 80 output_base = 0; 81 else 82 output_base = output_section->vma; 83 84 if (!relocatable || !strcmp (symbol->name, symbol->section->name)) 85 relocation += output_base + symbol->section->output_offset; 86 87 if (!relocatable && !strcmp (symbol->name, symbol->section->name)) 88 relocation += reloc_entry->addend; 89 90 relocation -= input_section->output_section->vma + input_section->output_offset; 91 relocation -= reloc_entry->address; 92 93 if (howto->complain_on_overflow != complain_overflow_dont) 94 { 95 bfd_reloc_status_type status; 96 status = bfd_check_overflow (howto->complain_on_overflow, 97 howto->bitsize, 98 howto->rightshift, 99 bfd_arch_bits_per_address(abfd), 100 relocation); 101 if (status != bfd_reloc_ok) 102 return status; 103 } 104 105 /* if rightshift is 1 and the number odd, return error. */ 106 if (howto->rightshift && (relocation & 0x01)) 107 { 108 _bfd_error_handler (_("relocation should be even number")); 109 return bfd_reloc_overflow; 110 } 111 112 relocation >>= (bfd_vma) howto->rightshift; 113 /* Shift everything up to where it's going to be used. */ 114 115 relocation <<= (bfd_vma) howto->bitpos; 116 117 if (relocatable) 118 { 119 reloc_entry->address += input_section->output_offset; 120 reloc_entry->addend += symbol->section->output_offset; 121 } 122 123 { 124 short x; 125 126 /* We are getting reloc_entry->address 2 byte off from 127 the start of instruction. Assuming absolute postion 128 of the reloc data. But, following code had been written assuming 129 reloc address is starting at begining of instruction. 130 To compensate that I have increased the value of 131 relocation by 1 (effectively 2) and used the addr -2 instead of addr. */ 132 133 relocation += 1; 134 x = bfd_get_16 (abfd, (bfd_byte *) data + addr - 2); 135 x = (x & 0xff00) | ((relocation >> 16) & 0xff); 136 bfd_put_16 (abfd, x, (unsigned char *) data + addr - 2); 137 138 x = bfd_get_16 (abfd, (bfd_byte *) data + addr); 139 x = relocation & 0xFFFF; 140 bfd_put_16 (abfd, x, (unsigned char *) data + addr ); 141 } 142 return bfd_reloc_ok; 143 } 144 145 static bfd_reloc_status_type 146 bfin_imm16_reloc (bfd *abfd, 147 arelent *reloc_entry, 148 asymbol *symbol, 149 void * data, 150 asection *input_section, 151 bfd *output_bfd, 152 char **error_message ATTRIBUTE_UNUSED) 153 { 154 bfd_vma relocation, x; 155 bfd_size_type reloc_addr = reloc_entry->address; 156 bfd_vma output_base = 0; 157 reloc_howto_type *howto = reloc_entry->howto; 158 asection *output_section; 159 bfd_boolean relocatable = (output_bfd != NULL); 160 161 /* Is the address of the relocation really within the section? */ 162 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 163 return bfd_reloc_outofrange; 164 165 if (bfd_is_und_section (symbol->section) 166 && (symbol->flags & BSF_WEAK) == 0 167 && !relocatable) 168 return bfd_reloc_undefined; 169 170 output_section = symbol->section->output_section; 171 relocation = symbol->value; 172 173 /* Convert input-section-relative symbol value to absolute. */ 174 if (relocatable) 175 output_base = 0; 176 else 177 output_base = output_section->vma; 178 179 if (!relocatable || !strcmp (symbol->name, symbol->section->name)) 180 relocation += output_base + symbol->section->output_offset; 181 182 /* Add in supplied addend. */ 183 relocation += reloc_entry->addend; 184 185 if (relocatable) 186 { 187 reloc_entry->address += input_section->output_offset; 188 reloc_entry->addend += symbol->section->output_offset; 189 } 190 else 191 { 192 reloc_entry->addend = 0; 193 } 194 195 if (howto->complain_on_overflow != complain_overflow_dont) 196 { 197 bfd_reloc_status_type flag; 198 flag = bfd_check_overflow (howto->complain_on_overflow, 199 howto->bitsize, 200 howto->rightshift, 201 bfd_arch_bits_per_address(abfd), 202 relocation); 203 if (flag != bfd_reloc_ok) 204 return flag; 205 } 206 207 /* Here the variable relocation holds the final address of the 208 symbol we are relocating against, plus any addend. */ 209 210 relocation >>= (bfd_vma) howto->rightshift; 211 x = relocation; 212 bfd_put_16 (abfd, x, (unsigned char *) data + reloc_addr); 213 return bfd_reloc_ok; 214 } 215 216 217 static bfd_reloc_status_type 218 bfin_byte4_reloc (bfd *abfd, 219 arelent *reloc_entry, 220 asymbol *symbol, 221 void * data, 222 asection *input_section, 223 bfd *output_bfd, 224 char **error_message ATTRIBUTE_UNUSED) 225 { 226 bfd_vma relocation, x; 227 bfd_size_type addr = reloc_entry->address; 228 bfd_vma output_base = 0; 229 asection *output_section; 230 bfd_boolean relocatable = (output_bfd != NULL); 231 232 /* Is the address of the relocation really within the section? */ 233 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 234 return bfd_reloc_outofrange; 235 236 if (bfd_is_und_section (symbol->section) 237 && (symbol->flags & BSF_WEAK) == 0 238 && !relocatable) 239 return bfd_reloc_undefined; 240 241 output_section = symbol->section->output_section; 242 relocation = symbol->value; 243 /* Convert input-section-relative symbol value to absolute. */ 244 if (relocatable) 245 output_base = 0; 246 else 247 output_base = output_section->vma; 248 249 if ((symbol->name 250 && symbol->section->name 251 && !strcmp (symbol->name, symbol->section->name)) 252 || !relocatable) 253 { 254 relocation += output_base + symbol->section->output_offset; 255 } 256 257 relocation += reloc_entry->addend; 258 259 if (relocatable) 260 { 261 /* This output will be relocatable ... like ld -r. */ 262 reloc_entry->address += input_section->output_offset; 263 reloc_entry->addend += symbol->section->output_offset; 264 } 265 else 266 { 267 reloc_entry->addend = 0; 268 } 269 270 /* Here the variable relocation holds the final address of the 271 symbol we are relocating against, plus any addend. */ 272 x = relocation & 0xFFFF0000; 273 x >>=16; 274 bfd_put_16 (abfd, x, (unsigned char *) data + addr + 2); 275 276 x = relocation & 0x0000FFFF; 277 bfd_put_16 (abfd, x, (unsigned char *) data + addr); 278 return bfd_reloc_ok; 279 } 280 281 /* bfin_bfd_reloc handles the blackfin arithmetic relocations. 282 Use this instead of bfd_perform_relocation. */ 283 static bfd_reloc_status_type 284 bfin_bfd_reloc (bfd *abfd, 285 arelent *reloc_entry, 286 asymbol *symbol, 287 void * data, 288 asection *input_section, 289 bfd *output_bfd, 290 char **error_message ATTRIBUTE_UNUSED) 291 { 292 bfd_vma relocation; 293 bfd_size_type addr = reloc_entry->address; 294 bfd_vma output_base = 0; 295 reloc_howto_type *howto = reloc_entry->howto; 296 asection *output_section; 297 bfd_boolean relocatable = (output_bfd != NULL); 298 299 /* Is the address of the relocation really within the section? */ 300 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 301 return bfd_reloc_outofrange; 302 303 if (bfd_is_und_section (symbol->section) 304 && (symbol->flags & BSF_WEAK) == 0 305 && !relocatable) 306 return bfd_reloc_undefined; 307 308 /* Get symbol value. (Common symbols are special.) */ 309 if (bfd_is_com_section (symbol->section)) 310 relocation = 0; 311 else 312 relocation = symbol->value; 313 314 output_section = symbol->section->output_section; 315 316 /* Convert input-section-relative symbol value to absolute. */ 317 if (relocatable) 318 output_base = 0; 319 else 320 output_base = output_section->vma; 321 322 if (!relocatable || !strcmp (symbol->name, symbol->section->name)) 323 relocation += output_base + symbol->section->output_offset; 324 325 if (!relocatable && !strcmp (symbol->name, symbol->section->name)) 326 { 327 /* Add in supplied addend. */ 328 relocation += reloc_entry->addend; 329 } 330 331 /* Here the variable relocation holds the final address of the 332 symbol we are relocating against, plus any addend. */ 333 334 if (howto->pc_relative) 335 { 336 relocation -= input_section->output_section->vma + input_section->output_offset; 337 338 if (howto->pcrel_offset) 339 relocation -= reloc_entry->address; 340 } 341 342 if (relocatable) 343 { 344 reloc_entry->address += input_section->output_offset; 345 reloc_entry->addend += symbol->section->output_offset; 346 } 347 348 if (howto->complain_on_overflow != complain_overflow_dont) 349 { 350 bfd_reloc_status_type status; 351 352 status = bfd_check_overflow (howto->complain_on_overflow, 353 howto->bitsize, 354 howto->rightshift, 355 bfd_arch_bits_per_address(abfd), 356 relocation); 357 if (status != bfd_reloc_ok) 358 return status; 359 } 360 361 /* If rightshift is 1 and the number odd, return error. */ 362 if (howto->rightshift && (relocation & 0x01)) 363 { 364 _bfd_error_handler (_("relocation should be even number")); 365 return bfd_reloc_overflow; 366 } 367 368 relocation >>= (bfd_vma) howto->rightshift; 369 370 /* Shift everything up to where it's going to be used. */ 371 372 relocation <<= (bfd_vma) howto->bitpos; 373 374 #define DOIT(x) \ 375 x = ( (x & ~howto->dst_mask) | (relocation & howto->dst_mask)) 376 377 /* handle 8 and 16 bit relocations here. */ 378 switch (howto->size) 379 { 380 case 0: 381 { 382 char x = bfd_get_8 (abfd, (char *) data + addr); 383 DOIT (x); 384 bfd_put_8 (abfd, x, (unsigned char *) data + addr); 385 } 386 break; 387 388 case 1: 389 { 390 unsigned short x = bfd_get_16 (abfd, (bfd_byte *) data + addr); 391 DOIT (x); 392 bfd_put_16 (abfd, (bfd_vma) x, (unsigned char *) data + addr); 393 } 394 break; 395 396 default: 397 return bfd_reloc_other; 398 } 399 400 return bfd_reloc_ok; 401 } 402 403 /* HOWTO Table for blackfin. 404 Blackfin relocations are fairly complicated. 405 Some of the salient features are 406 a. Even numbered offsets. A number of (not all) relocations are 407 even numbered. This means that the rightmost bit is not stored. 408 Needs to right shift by 1 and check to see if value is not odd 409 b. A relocation can be an expression. An expression takes on 410 a variety of relocations arranged in a stack. 411 As a result, we cannot use the standard generic function as special 412 function. We will have our own, which is very similar to the standard 413 generic function except that it understands how to get the value from 414 the relocation stack. . */ 415 416 #define BFIN_RELOC_MIN 0 417 #define BFIN_RELOC_MAX 0x21 418 #define BFIN_GNUEXT_RELOC_MIN 0x40 419 #define BFIN_GNUEXT_RELOC_MAX 0x43 420 #define BFIN_ARELOC_MIN 0xE0 421 #define BFIN_ARELOC_MAX 0xF3 422 423 static reloc_howto_type bfin_howto_table [] = 424 { 425 /* This reloc does nothing. . */ 426 HOWTO (R_BFIN_UNUSED0, /* type. */ 427 0, /* rightshift. */ 428 3, /* size (0 = byte, 1 = short, 2 = long). */ 429 0, /* bitsize. */ 430 FALSE, /* pc_relative. */ 431 0, /* bitpos. */ 432 complain_overflow_dont, /* complain_on_overflow. */ 433 bfd_elf_generic_reloc, /* special_function. */ 434 "R_BFIN_UNUSED0", /* name. */ 435 FALSE, /* partial_inplace. */ 436 0, /* src_mask. */ 437 0, /* dst_mask. */ 438 FALSE), /* pcrel_offset. */ 439 440 HOWTO (R_BFIN_PCREL5M2, /* type. */ 441 1, /* rightshift. */ 442 1, /* size (0 = byte, 1 = short, 2 = long).. */ 443 4, /* bitsize. */ 444 TRUE, /* pc_relative. */ 445 0, /* bitpos. */ 446 complain_overflow_unsigned, /* complain_on_overflow. */ 447 bfin_bfd_reloc, /* special_function. */ 448 "R_BFIN_PCREL5M2", /* name. */ 449 FALSE, /* partial_inplace. */ 450 0, /* src_mask. */ 451 0x0000000F, /* dst_mask. */ 452 FALSE), /* pcrel_offset. */ 453 454 HOWTO (R_BFIN_UNUSED1, /* type. */ 455 0, /* rightshift. */ 456 3, /* size (0 = byte, 1 = short, 2 = long). */ 457 0, /* bitsize. */ 458 FALSE, /* pc_relative. */ 459 0, /* bitpos. */ 460 complain_overflow_dont, /* complain_on_overflow. */ 461 bfd_elf_generic_reloc, /* special_function. */ 462 "R_BFIN_UNUSED1", /* name. */ 463 FALSE, /* partial_inplace. */ 464 0, /* src_mask. */ 465 0, /* dst_mask. */ 466 FALSE), /* pcrel_offset. */ 467 468 HOWTO (R_BFIN_PCREL10, /* type. */ 469 1, /* rightshift. */ 470 1, /* size (0 = byte, 1 = short, 2 = long). */ 471 10, /* bitsize. */ 472 TRUE, /* pc_relative. */ 473 0, /* bitpos. */ 474 complain_overflow_signed, /* complain_on_overflow. */ 475 bfin_bfd_reloc, /* special_function. */ 476 "R_BFIN_PCREL10", /* name. */ 477 FALSE, /* partial_inplace. */ 478 0, /* src_mask. */ 479 0x000003FF, /* dst_mask. */ 480 TRUE), /* pcrel_offset. */ 481 482 HOWTO (R_BFIN_PCREL12_JUMP, /* type. */ 483 1, /* rightshift. */ 484 /* the offset is actually 13 bit 485 aligned on a word boundary so 486 only 12 bits have to be used. 487 Right shift the rightmost bit.. */ 488 1, /* size (0 = byte, 1 = short, 2 = long). */ 489 12, /* bitsize. */ 490 TRUE, /* pc_relative. */ 491 0, /* bitpos. */ 492 complain_overflow_signed, /* complain_on_overflow. */ 493 bfin_bfd_reloc, /* special_function. */ 494 "R_BFIN_PCREL12_JUMP", /* name. */ 495 FALSE, /* partial_inplace. */ 496 0, /* src_mask. */ 497 0x0FFF, /* dst_mask. */ 498 TRUE), /* pcrel_offset. */ 499 500 HOWTO (R_BFIN_RIMM16, /* type. */ 501 0, /* rightshift. */ 502 1, /* size (0 = byte, 1 = short, 2 = long). */ 503 16, /* bitsize. */ 504 FALSE, /* pc_relative. */ 505 0, /* bitpos. */ 506 complain_overflow_signed, /* complain_on_overflow. */ 507 bfin_imm16_reloc, /* special_function. */ 508 "R_BFIN_RIMM16", /* name. */ 509 FALSE, /* partial_inplace. */ 510 0, /* src_mask. */ 511 0x0000FFFF, /* dst_mask. */ 512 TRUE), /* pcrel_offset. */ 513 514 HOWTO (R_BFIN_LUIMM16, /* type. */ 515 0, /* rightshift. */ 516 1, /* size (0 = byte, 1 = short, 2 = long). */ 517 16, /* bitsize. */ 518 FALSE, /* pc_relative. */ 519 0, /* bitpos. */ 520 complain_overflow_dont, /* complain_on_overflow. */ 521 bfin_imm16_reloc, /* special_function. */ 522 "R_BFIN_LUIMM16", /* name. */ 523 FALSE, /* partial_inplace. */ 524 0, /* src_mask. */ 525 0x0000FFFF, /* dst_mask. */ 526 TRUE), /* pcrel_offset. */ 527 528 HOWTO (R_BFIN_HUIMM16, /* type. */ 529 16, /* rightshift. */ 530 1, /* size (0 = byte, 1 = short, 2 = long). */ 531 16, /* bitsize. */ 532 FALSE, /* pc_relative. */ 533 0, /* bitpos. */ 534 complain_overflow_unsigned, /* complain_on_overflow. */ 535 bfin_imm16_reloc, /* special_function. */ 536 "R_BFIN_HUIMM16", /* name. */ 537 FALSE, /* partial_inplace. */ 538 0, /* src_mask. */ 539 0x0000FFFF, /* dst_mask. */ 540 TRUE), /* pcrel_offset. */ 541 542 HOWTO (R_BFIN_PCREL12_JUMP_S, /* type. */ 543 1, /* rightshift. */ 544 1, /* size (0 = byte, 1 = short, 2 = long). */ 545 12, /* bitsize. */ 546 TRUE, /* pc_relative. */ 547 0, /* bitpos. */ 548 complain_overflow_signed, /* complain_on_overflow. */ 549 bfin_bfd_reloc, /* special_function. */ 550 "R_BFIN_PCREL12_JUMP_S", /* name. */ 551 FALSE, /* partial_inplace. */ 552 0, /* src_mask. */ 553 0x00000FFF, /* dst_mask. */ 554 TRUE), /* pcrel_offset. */ 555 556 HOWTO (R_BFIN_PCREL24_JUMP_X, /* type. */ 557 1, /* rightshift. */ 558 2, /* size (0 = byte, 1 = short, 2 = long). */ 559 24, /* bitsize. */ 560 TRUE, /* pc_relative. */ 561 0, /* bitpos. */ 562 complain_overflow_signed, /* complain_on_overflow. */ 563 bfin_pcrel24_reloc, /* special_function. */ 564 "R_BFIN_PCREL24_JUMP_X", /* name. */ 565 FALSE, /* partial_inplace. */ 566 0, /* src_mask. */ 567 0x00FFFFFF, /* dst_mask. */ 568 TRUE), /* pcrel_offset. */ 569 570 HOWTO (R_BFIN_PCREL24, /* type. */ 571 1, /* rightshift. */ 572 2, /* size (0 = byte, 1 = short, 2 = long). */ 573 24, /* bitsize. */ 574 TRUE, /* pc_relative. */ 575 0, /* bitpos. */ 576 complain_overflow_signed, /* complain_on_overflow. */ 577 bfin_pcrel24_reloc, /* special_function. */ 578 "R_BFIN_PCREL24", /* name. */ 579 FALSE, /* partial_inplace. */ 580 0, /* src_mask. */ 581 0x00FFFFFF, /* dst_mask. */ 582 TRUE), /* pcrel_offset. */ 583 584 HOWTO (R_BFIN_UNUSEDB, /* type. */ 585 0, /* rightshift. */ 586 3, /* size (0 = byte, 1 = short, 2 = long). */ 587 0, /* bitsize. */ 588 FALSE, /* pc_relative. */ 589 0, /* bitpos. */ 590 complain_overflow_dont, /* complain_on_overflow. */ 591 bfd_elf_generic_reloc, /* special_function. */ 592 "R_BFIN_UNUSEDB", /* name. */ 593 FALSE, /* partial_inplace. */ 594 0, /* src_mask. */ 595 0, /* dst_mask. */ 596 FALSE), /* pcrel_offset. */ 597 598 HOWTO (R_BFIN_UNUSEDC, /* type. */ 599 0, /* rightshift. */ 600 3, /* size (0 = byte, 1 = short, 2 = long). */ 601 0, /* bitsize. */ 602 FALSE, /* pc_relative. */ 603 0, /* bitpos. */ 604 complain_overflow_dont, /* complain_on_overflow. */ 605 bfd_elf_generic_reloc, /* special_function. */ 606 "R_BFIN_UNUSEDC", /* name. */ 607 FALSE, /* partial_inplace. */ 608 0, /* src_mask. */ 609 0, /* dst_mask. */ 610 FALSE), /* pcrel_offset. */ 611 612 HOWTO (R_BFIN_PCREL24_JUMP_L, /* type. */ 613 1, /* rightshift. */ 614 2, /* size (0 = byte, 1 = short, 2 = long). */ 615 24, /* bitsize. */ 616 TRUE, /* pc_relative. */ 617 0, /* bitpos. */ 618 complain_overflow_signed, /* complain_on_overflow. */ 619 bfin_pcrel24_reloc, /* special_function. */ 620 "R_BFIN_PCREL24_JUMP_L", /* name. */ 621 FALSE, /* partial_inplace. */ 622 0, /* src_mask. */ 623 0x00FFFFFF, /* dst_mask. */ 624 TRUE), /* pcrel_offset. */ 625 626 HOWTO (R_BFIN_PCREL24_CALL_X, /* type. */ 627 1, /* rightshift. */ 628 2, /* size (0 = byte, 1 = short, 2 = long). */ 629 24, /* bitsize. */ 630 TRUE, /* pc_relative. */ 631 0, /* bitpos. */ 632 complain_overflow_signed, /* complain_on_overflow. */ 633 bfin_pcrel24_reloc, /* special_function. */ 634 "R_BFIN_PCREL24_CALL_X", /* name. */ 635 FALSE, /* partial_inplace. */ 636 0, /* src_mask. */ 637 0x00FFFFFF, /* dst_mask. */ 638 TRUE), /* pcrel_offset. */ 639 640 HOWTO (R_BFIN_VAR_EQ_SYMB, /* type. */ 641 0, /* rightshift. */ 642 2, /* size (0 = byte, 1 = short, 2 = long). */ 643 32, /* bitsize. */ 644 FALSE, /* pc_relative. */ 645 0, /* bitpos. */ 646 complain_overflow_bitfield, /* complain_on_overflow. */ 647 bfin_bfd_reloc, /* special_function. */ 648 "R_BFIN_VAR_EQ_SYMB", /* name. */ 649 FALSE, /* partial_inplace. */ 650 0, /* src_mask. */ 651 0, /* dst_mask. */ 652 FALSE), /* pcrel_offset. */ 653 654 HOWTO (R_BFIN_BYTE_DATA, /* type. */ 655 0, /* rightshift. */ 656 0, /* size (0 = byte, 1 = short, 2 = long). */ 657 8, /* bitsize. */ 658 FALSE, /* pc_relative. */ 659 0, /* bitpos. */ 660 complain_overflow_unsigned, /* complain_on_overflow. */ 661 bfin_bfd_reloc, /* special_function. */ 662 "R_BFIN_BYTE_DATA", /* name. */ 663 FALSE, /* partial_inplace. */ 664 0, /* src_mask. */ 665 0xFF, /* dst_mask. */ 666 TRUE), /* pcrel_offset. */ 667 668 HOWTO (R_BFIN_BYTE2_DATA, /* type. */ 669 0, /* rightshift. */ 670 1, /* size (0 = byte, 1 = short, 2 = long). */ 671 16, /* bitsize. */ 672 FALSE, /* pc_relative. */ 673 0, /* bitpos. */ 674 complain_overflow_signed, /* complain_on_overflow. */ 675 bfin_bfd_reloc, /* special_function. */ 676 "R_BFIN_BYTE2_DATA", /* name. */ 677 FALSE, /* partial_inplace. */ 678 0, /* src_mask. */ 679 0xFFFF, /* dst_mask. */ 680 TRUE), /* pcrel_offset. */ 681 682 HOWTO (R_BFIN_BYTE4_DATA, /* type. */ 683 0, /* rightshift. */ 684 2, /* size (0 = byte, 1 = short, 2 = long). */ 685 32, /* bitsize. */ 686 FALSE, /* pc_relative. */ 687 0, /* bitpos. */ 688 complain_overflow_unsigned, /* complain_on_overflow. */ 689 bfin_byte4_reloc, /* special_function. */ 690 "R_BFIN_BYTE4_DATA", /* name. */ 691 FALSE, /* partial_inplace. */ 692 0, /* src_mask. */ 693 0xFFFFFFFF, /* dst_mask. */ 694 TRUE), /* pcrel_offset. */ 695 696 HOWTO (R_BFIN_PCREL11, /* type. */ 697 1, /* rightshift. */ 698 1, /* size (0 = byte, 1 = short, 2 = long). */ 699 10, /* bitsize. */ 700 TRUE, /* pc_relative. */ 701 0, /* bitpos. */ 702 complain_overflow_unsigned, /* complain_on_overflow. */ 703 bfin_bfd_reloc, /* special_function. */ 704 "R_BFIN_PCREL11", /* name. */ 705 FALSE, /* partial_inplace. */ 706 0, /* src_mask. */ 707 0x000003FF, /* dst_mask. */ 708 FALSE), /* pcrel_offset. */ 709 710 711 /* A 18-bit signed operand with the GOT offset for the address of 712 the symbol. */ 713 HOWTO (R_BFIN_GOT17M4, /* type */ 714 2, /* rightshift */ 715 1, /* size (0 = byte, 1 = short, 2 = long) */ 716 16, /* bitsize */ 717 FALSE, /* pc_relative */ 718 0, /* bitpos */ 719 complain_overflow_signed, /* complain_on_overflow */ 720 bfd_elf_generic_reloc, /* special_function */ 721 "R_BFIN_GOT17M4", /* name */ 722 FALSE, /* partial_inplace */ 723 0xffff, /* src_mask */ 724 0xffff, /* dst_mask */ 725 FALSE), /* pcrel_offset */ 726 727 /* The upper 16 bits of the GOT offset for the address of the 728 symbol. */ 729 HOWTO (R_BFIN_GOTHI, /* type */ 730 0, /* rightshift */ 731 1, /* size (0 = byte, 1 = short, 2 = long) */ 732 16, /* bitsize */ 733 FALSE, /* pc_relative */ 734 0, /* bitpos */ 735 complain_overflow_dont, /* complain_on_overflow */ 736 bfd_elf_generic_reloc, /* special_function */ 737 "R_BFIN_GOTHI", /* name */ 738 FALSE, /* partial_inplace */ 739 0xffff, /* src_mask */ 740 0xffff, /* dst_mask */ 741 FALSE), /* pcrel_offset */ 742 743 /* The lower 16 bits of the GOT offset for the address of the 744 symbol. */ 745 HOWTO (R_BFIN_GOTLO, /* type */ 746 0, /* rightshift */ 747 1, /* size (0 = byte, 1 = short, 2 = long) */ 748 16, /* bitsize */ 749 FALSE, /* pc_relative */ 750 0, /* bitpos */ 751 complain_overflow_dont, /* complain_on_overflow */ 752 bfd_elf_generic_reloc, /* special_function */ 753 "R_BFIN_GOTLO", /* name */ 754 FALSE, /* partial_inplace */ 755 0xffff, /* src_mask */ 756 0xffff, /* dst_mask */ 757 FALSE), /* pcrel_offset */ 758 759 /* The 32-bit address of the canonical descriptor of a function. */ 760 HOWTO (R_BFIN_FUNCDESC, /* type */ 761 0, /* rightshift */ 762 2, /* size (0 = byte, 1 = short, 2 = long) */ 763 32, /* bitsize */ 764 FALSE, /* pc_relative */ 765 0, /* bitpos */ 766 complain_overflow_bitfield, /* complain_on_overflow */ 767 bfd_elf_generic_reloc, /* special_function */ 768 "R_BFIN_FUNCDESC", /* name */ 769 FALSE, /* partial_inplace */ 770 0xffffffff, /* src_mask */ 771 0xffffffff, /* dst_mask */ 772 FALSE), /* pcrel_offset */ 773 774 /* A 12-bit signed operand with the GOT offset for the address of 775 canonical descriptor of a function. */ 776 HOWTO (R_BFIN_FUNCDESC_GOT17M4, /* type */ 777 2, /* rightshift */ 778 1, /* size (0 = byte, 1 = short, 2 = long) */ 779 16, /* bitsize */ 780 FALSE, /* pc_relative */ 781 0, /* bitpos */ 782 complain_overflow_signed, /* complain_on_overflow */ 783 bfd_elf_generic_reloc, /* special_function */ 784 "R_BFIN_FUNCDESC_GOT17M4", /* name */ 785 FALSE, /* partial_inplace */ 786 0xffff, /* src_mask */ 787 0xffff, /* dst_mask */ 788 FALSE), /* pcrel_offset */ 789 790 /* The upper 16 bits of the GOT offset for the address of the 791 canonical descriptor of a function. */ 792 HOWTO (R_BFIN_FUNCDESC_GOTHI, /* type */ 793 0, /* rightshift */ 794 1, /* size (0 = byte, 1 = short, 2 = long) */ 795 16, /* bitsize */ 796 FALSE, /* pc_relative */ 797 0, /* bitpos */ 798 complain_overflow_dont, /* complain_on_overflow */ 799 bfd_elf_generic_reloc, /* special_function */ 800 "R_BFIN_FUNCDESC_GOTHI", /* name */ 801 FALSE, /* partial_inplace */ 802 0xffff, /* src_mask */ 803 0xffff, /* dst_mask */ 804 FALSE), /* pcrel_offset */ 805 806 /* The lower 16 bits of the GOT offset for the address of the 807 canonical descriptor of a function. */ 808 HOWTO (R_BFIN_FUNCDESC_GOTLO, /* type */ 809 0, /* rightshift */ 810 1, /* size (0 = byte, 1 = short, 2 = long) */ 811 16, /* bitsize */ 812 FALSE, /* pc_relative */ 813 0, /* bitpos */ 814 complain_overflow_dont, /* complain_on_overflow */ 815 bfd_elf_generic_reloc, /* special_function */ 816 "R_BFIN_FUNCDESC_GOTLO", /* name */ 817 FALSE, /* partial_inplace */ 818 0xffff, /* src_mask */ 819 0xffff, /* dst_mask */ 820 FALSE), /* pcrel_offset */ 821 822 /* The 32-bit address of the canonical descriptor of a function. */ 823 HOWTO (R_BFIN_FUNCDESC_VALUE, /* type */ 824 0, /* rightshift */ 825 2, /* size (0 = byte, 1 = short, 2 = long) */ 826 64, /* bitsize */ 827 FALSE, /* pc_relative */ 828 0, /* bitpos */ 829 complain_overflow_bitfield, /* complain_on_overflow */ 830 bfd_elf_generic_reloc, /* special_function */ 831 "R_BFIN_FUNCDESC_VALUE", /* name */ 832 FALSE, /* partial_inplace */ 833 0xffffffff, /* src_mask */ 834 0xffffffff, /* dst_mask */ 835 FALSE), /* pcrel_offset */ 836 837 /* A 12-bit signed operand with the GOT offset for the address of 838 canonical descriptor of a function. */ 839 HOWTO (R_BFIN_FUNCDESC_GOTOFF17M4, /* type */ 840 2, /* rightshift */ 841 1, /* size (0 = byte, 1 = short, 2 = long) */ 842 16, /* bitsize */ 843 FALSE, /* pc_relative */ 844 0, /* bitpos */ 845 complain_overflow_signed, /* complain_on_overflow */ 846 bfd_elf_generic_reloc, /* special_function */ 847 "R_BFIN_FUNCDESC_GOTOFF17M4", /* name */ 848 FALSE, /* partial_inplace */ 849 0xffff, /* src_mask */ 850 0xffff, /* dst_mask */ 851 FALSE), /* pcrel_offset */ 852 853 /* The upper 16 bits of the GOT offset for the address of the 854 canonical descriptor of a function. */ 855 HOWTO (R_BFIN_FUNCDESC_GOTOFFHI, /* type */ 856 0, /* rightshift */ 857 1, /* size (0 = byte, 1 = short, 2 = long) */ 858 16, /* bitsize */ 859 FALSE, /* pc_relative */ 860 0, /* bitpos */ 861 complain_overflow_dont, /* complain_on_overflow */ 862 bfd_elf_generic_reloc, /* special_function */ 863 "R_BFIN_FUNCDESC_GOTOFFHI", /* name */ 864 FALSE, /* partial_inplace */ 865 0xffff, /* src_mask */ 866 0xffff, /* dst_mask */ 867 FALSE), /* pcrel_offset */ 868 869 /* The lower 16 bits of the GOT offset for the address of the 870 canonical descriptor of a function. */ 871 HOWTO (R_BFIN_FUNCDESC_GOTOFFLO, /* type */ 872 0, /* rightshift */ 873 1, /* size (0 = byte, 1 = short, 2 = long) */ 874 16, /* bitsize */ 875 FALSE, /* pc_relative */ 876 0, /* bitpos */ 877 complain_overflow_dont, /* complain_on_overflow */ 878 bfd_elf_generic_reloc, /* special_function */ 879 "R_BFIN_FUNCDESC_GOTOFFLO", /* name */ 880 FALSE, /* partial_inplace */ 881 0xffff, /* src_mask */ 882 0xffff, /* dst_mask */ 883 FALSE), /* pcrel_offset */ 884 885 /* A 12-bit signed operand with the GOT offset for the address of 886 the symbol. */ 887 HOWTO (R_BFIN_GOTOFF17M4, /* type */ 888 2, /* rightshift */ 889 1, /* size (0 = byte, 1 = short, 2 = long) */ 890 16, /* bitsize */ 891 FALSE, /* pc_relative */ 892 0, /* bitpos */ 893 complain_overflow_signed, /* complain_on_overflow */ 894 bfd_elf_generic_reloc, /* special_function */ 895 "R_BFIN_GOTOFF17M4", /* name */ 896 FALSE, /* partial_inplace */ 897 0xffff, /* src_mask */ 898 0xffff, /* dst_mask */ 899 FALSE), /* pcrel_offset */ 900 901 /* The upper 16 bits of the GOT offset for the address of the 902 symbol. */ 903 HOWTO (R_BFIN_GOTOFFHI, /* type */ 904 0, /* rightshift */ 905 1, /* size (0 = byte, 1 = short, 2 = long) */ 906 16, /* bitsize */ 907 FALSE, /* pc_relative */ 908 0, /* bitpos */ 909 complain_overflow_dont, /* complain_on_overflow */ 910 bfd_elf_generic_reloc, /* special_function */ 911 "R_BFIN_GOTOFFHI", /* name */ 912 FALSE, /* partial_inplace */ 913 0xffff, /* src_mask */ 914 0xffff, /* dst_mask */ 915 FALSE), /* pcrel_offset */ 916 917 /* The lower 16 bits of the GOT offset for the address of the 918 symbol. */ 919 HOWTO (R_BFIN_GOTOFFLO, /* type */ 920 0, /* rightshift */ 921 1, /* size (0 = byte, 1 = short, 2 = long) */ 922 16, /* bitsize */ 923 FALSE, /* pc_relative */ 924 0, /* bitpos */ 925 complain_overflow_dont, /* complain_on_overflow */ 926 bfd_elf_generic_reloc, /* special_function */ 927 "R_BFIN_GOTOFFLO", /* name */ 928 FALSE, /* partial_inplace */ 929 0xffff, /* src_mask */ 930 0xffff, /* dst_mask */ 931 FALSE), /* pcrel_offset */ 932 }; 933 934 static reloc_howto_type bfin_gnuext_howto_table [] = 935 { 936 HOWTO (R_BFIN_PLTPC, /* type. */ 937 0, /* rightshift. */ 938 1, /* size (0 = byte, 1 = short, 2 = long). */ 939 16, /* bitsize. */ 940 FALSE, /* pc_relative. */ 941 0, /* bitpos. */ 942 complain_overflow_bitfield, /* complain_on_overflow. */ 943 bfin_pltpc_reloc, /* special_function. */ 944 "R_BFIN_PLTPC", /* name. */ 945 FALSE, /* partial_inplace. */ 946 0xffff, /* src_mask. */ 947 0xffff, /* dst_mask. */ 948 FALSE), /* pcrel_offset. */ 949 950 HOWTO (R_BFIN_GOT, /* type. */ 951 0, /* rightshift. */ 952 1, /* size (0 = byte, 1 = short, 2 = long). */ 953 16, /* bitsize. */ 954 FALSE, /* pc_relative. */ 955 0, /* bitpos. */ 956 complain_overflow_bitfield, /* complain_on_overflow. */ 957 bfd_elf_generic_reloc, /* special_function. */ 958 "R_BFIN_GOT", /* name. */ 959 FALSE, /* partial_inplace. */ 960 0x7fff, /* src_mask. */ 961 0x7fff, /* dst_mask. */ 962 FALSE), /* pcrel_offset. */ 963 964 /* GNU extension to record C++ vtable hierarchy. */ 965 HOWTO (R_BFIN_GNU_VTINHERIT, /* type. */ 966 0, /* rightshift. */ 967 2, /* size (0 = byte, 1 = short, 2 = long). */ 968 0, /* bitsize. */ 969 FALSE, /* pc_relative. */ 970 0, /* bitpos. */ 971 complain_overflow_dont, /* complain_on_overflow. */ 972 NULL, /* special_function. */ 973 "R_BFIN_GNU_VTINHERIT", /* name. */ 974 FALSE, /* partial_inplace. */ 975 0, /* src_mask. */ 976 0, /* dst_mask. */ 977 FALSE), /* pcrel_offset. */ 978 979 /* GNU extension to record C++ vtable member usage. */ 980 HOWTO (R_BFIN_GNU_VTENTRY, /* type. */ 981 0, /* rightshift. */ 982 2, /* size (0 = byte, 1 = short, 2 = long). */ 983 0, /* bitsize. */ 984 FALSE, /* pc_relative. */ 985 0, /* bitpos. */ 986 complain_overflow_dont, /* complain_on_overflow. */ 987 _bfd_elf_rel_vtable_reloc_fn, /* special_function. */ 988 "R_BFIN_GNU_VTENTRY", /* name. */ 989 FALSE, /* partial_inplace. */ 990 0, /* src_mask. */ 991 0, /* dst_mask. */ 992 FALSE) /* pcrel_offset. */ 993 }; 994 995 struct bfin_reloc_map 996 { 997 bfd_reloc_code_real_type bfd_reloc_val; 998 unsigned int bfin_reloc_val; 999 }; 1000 1001 static const struct bfin_reloc_map bfin_reloc_map [] = 1002 { 1003 { BFD_RELOC_NONE, R_BFIN_UNUSED0 }, 1004 { BFD_RELOC_BFIN_5_PCREL, R_BFIN_PCREL5M2 }, 1005 { BFD_RELOC_NONE, R_BFIN_UNUSED1 }, 1006 { BFD_RELOC_BFIN_10_PCREL, R_BFIN_PCREL10 }, 1007 { BFD_RELOC_BFIN_12_PCREL_JUMP, R_BFIN_PCREL12_JUMP }, 1008 { BFD_RELOC_BFIN_16_IMM, R_BFIN_RIMM16 }, 1009 { BFD_RELOC_BFIN_16_LOW, R_BFIN_LUIMM16 }, 1010 { BFD_RELOC_BFIN_16_HIGH, R_BFIN_HUIMM16 }, 1011 { BFD_RELOC_BFIN_12_PCREL_JUMP_S, R_BFIN_PCREL12_JUMP_S }, 1012 { BFD_RELOC_24_PCREL, R_BFIN_PCREL24 }, 1013 { BFD_RELOC_24_PCREL, R_BFIN_PCREL24 }, 1014 { BFD_RELOC_BFIN_24_PCREL_JUMP_L, R_BFIN_PCREL24_JUMP_L }, 1015 { BFD_RELOC_NONE, R_BFIN_UNUSEDB }, 1016 { BFD_RELOC_NONE, R_BFIN_UNUSEDC }, 1017 { BFD_RELOC_BFIN_24_PCREL_CALL_X, R_BFIN_PCREL24_CALL_X }, 1018 { BFD_RELOC_8, R_BFIN_BYTE_DATA }, 1019 { BFD_RELOC_16, R_BFIN_BYTE2_DATA }, 1020 { BFD_RELOC_32, R_BFIN_BYTE4_DATA }, 1021 { BFD_RELOC_BFIN_11_PCREL, R_BFIN_PCREL11 }, 1022 { BFD_RELOC_BFIN_GOT, R_BFIN_GOT }, 1023 { BFD_RELOC_BFIN_PLTPC, R_BFIN_PLTPC }, 1024 1025 { BFD_RELOC_BFIN_GOT17M4, R_BFIN_GOT17M4 }, 1026 { BFD_RELOC_BFIN_GOTHI, R_BFIN_GOTHI }, 1027 { BFD_RELOC_BFIN_GOTLO, R_BFIN_GOTLO }, 1028 { BFD_RELOC_BFIN_FUNCDESC, R_BFIN_FUNCDESC }, 1029 { BFD_RELOC_BFIN_FUNCDESC_GOT17M4, R_BFIN_FUNCDESC_GOT17M4 }, 1030 { BFD_RELOC_BFIN_FUNCDESC_GOTHI, R_BFIN_FUNCDESC_GOTHI }, 1031 { BFD_RELOC_BFIN_FUNCDESC_GOTLO, R_BFIN_FUNCDESC_GOTLO }, 1032 { BFD_RELOC_BFIN_FUNCDESC_VALUE, R_BFIN_FUNCDESC_VALUE }, 1033 { BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4, R_BFIN_FUNCDESC_GOTOFF17M4 }, 1034 { BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI, R_BFIN_FUNCDESC_GOTOFFHI }, 1035 { BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO, R_BFIN_FUNCDESC_GOTOFFLO }, 1036 { BFD_RELOC_BFIN_GOTOFF17M4, R_BFIN_GOTOFF17M4 }, 1037 { BFD_RELOC_BFIN_GOTOFFHI, R_BFIN_GOTOFFHI }, 1038 { BFD_RELOC_BFIN_GOTOFFLO, R_BFIN_GOTOFFLO }, 1039 1040 { BFD_RELOC_VTABLE_INHERIT, R_BFIN_GNU_VTINHERIT }, 1041 { BFD_RELOC_VTABLE_ENTRY, R_BFIN_GNU_VTENTRY }, 1042 }; 1043 1044 1045 static bfd_boolean 1046 bfin_info_to_howto (bfd *abfd, 1047 arelent *cache_ptr, 1048 Elf_Internal_Rela *dst) 1049 { 1050 unsigned int r_type; 1051 1052 r_type = ELF32_R_TYPE (dst->r_info); 1053 1054 if (r_type <= BFIN_RELOC_MAX) 1055 cache_ptr->howto = &bfin_howto_table [r_type]; 1056 1057 else if (r_type >= BFIN_GNUEXT_RELOC_MIN && r_type <= BFIN_GNUEXT_RELOC_MAX) 1058 cache_ptr->howto = &bfin_gnuext_howto_table [r_type - BFIN_GNUEXT_RELOC_MIN]; 1059 1060 else 1061 { 1062 /* xgettext:c-format */ 1063 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 1064 abfd, r_type); 1065 bfd_set_error (bfd_error_bad_value); 1066 return FALSE; 1067 } 1068 1069 return TRUE; 1070 } 1071 1072 /* Given a BFD reloc type, return the howto. */ 1073 static reloc_howto_type * 1074 bfin_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED, 1075 bfd_reloc_code_real_type code) 1076 { 1077 unsigned int i; 1078 unsigned int r_type = (unsigned int) -1; 1079 1080 for (i = sizeof (bfin_reloc_map) / sizeof (bfin_reloc_map[0]); i--;) 1081 if (bfin_reloc_map[i].bfd_reloc_val == code) 1082 r_type = bfin_reloc_map[i].bfin_reloc_val; 1083 1084 if (r_type <= BFIN_RELOC_MAX) 1085 return &bfin_howto_table [r_type]; 1086 1087 else if (r_type >= BFIN_GNUEXT_RELOC_MIN && r_type <= BFIN_GNUEXT_RELOC_MAX) 1088 return &bfin_gnuext_howto_table [r_type - BFIN_GNUEXT_RELOC_MIN]; 1089 1090 return (reloc_howto_type *) NULL; 1091 } 1092 1093 static reloc_howto_type * 1094 bfin_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1095 const char *r_name) 1096 { 1097 unsigned int i; 1098 1099 for (i = 0; 1100 i < (sizeof (bfin_howto_table) 1101 / sizeof (bfin_howto_table[0])); 1102 i++) 1103 if (bfin_howto_table[i].name != NULL 1104 && strcasecmp (bfin_howto_table[i].name, r_name) == 0) 1105 return &bfin_howto_table[i]; 1106 1107 for (i = 0; 1108 i < (sizeof (bfin_gnuext_howto_table) 1109 / sizeof (bfin_gnuext_howto_table[0])); 1110 i++) 1111 if (bfin_gnuext_howto_table[i].name != NULL 1112 && strcasecmp (bfin_gnuext_howto_table[i].name, r_name) == 0) 1113 return &bfin_gnuext_howto_table[i]; 1114 1115 return NULL; 1116 } 1117 1118 /* Given a bfin relocation type, return the howto. */ 1119 static reloc_howto_type * 1120 bfin_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED, 1121 unsigned int r_type) 1122 { 1123 if (r_type <= BFIN_RELOC_MAX) 1124 return &bfin_howto_table [r_type]; 1125 1126 else if (r_type >= BFIN_GNUEXT_RELOC_MIN && r_type <= BFIN_GNUEXT_RELOC_MAX) 1127 return &bfin_gnuext_howto_table [r_type - BFIN_GNUEXT_RELOC_MIN]; 1128 1129 return (reloc_howto_type *) NULL; 1130 } 1131 1132 /* Set by ld emulation if --code-in-l1. */ 1133 bfd_boolean elf32_bfin_code_in_l1 = 0; 1134 1135 /* Set by ld emulation if --data-in-l1. */ 1136 bfd_boolean elf32_bfin_data_in_l1 = 0; 1137 1138 static bfd_boolean 1139 elf32_bfin_final_write_processing (bfd *abfd) 1140 { 1141 if (elf32_bfin_code_in_l1) 1142 elf_elfheader (abfd)->e_flags |= EF_BFIN_CODE_IN_L1; 1143 if (elf32_bfin_data_in_l1) 1144 elf_elfheader (abfd)->e_flags |= EF_BFIN_DATA_IN_L1; 1145 return _bfd_elf_final_write_processing (abfd); 1146 } 1147 1148 /* Return TRUE if the name is a local label. 1149 bfin local labels begin with L$. */ 1150 static bfd_boolean 1151 bfin_is_local_label_name (bfd *abfd, const char *label) 1152 { 1153 if (label[0] == 'L' && label[1] == '$' ) 1154 return TRUE; 1155 1156 return _bfd_elf_is_local_label_name (abfd, label); 1157 } 1158 1159 /* Look through the relocs for a section during the first phase, and 1161 allocate space in the global offset table or procedure linkage 1162 table. */ 1163 1164 static bfd_boolean 1165 bfin_check_relocs (bfd * abfd, 1166 struct bfd_link_info *info, 1167 asection *sec, 1168 const Elf_Internal_Rela *relocs) 1169 { 1170 bfd *dynobj; 1171 Elf_Internal_Shdr *symtab_hdr; 1172 struct elf_link_hash_entry **sym_hashes; 1173 bfd_signed_vma *local_got_refcounts; 1174 const Elf_Internal_Rela *rel; 1175 const Elf_Internal_Rela *rel_end; 1176 asection *sgot; 1177 asection *srelgot; 1178 1179 if (bfd_link_relocatable (info)) 1180 return TRUE; 1181 1182 dynobj = elf_hash_table (info)->dynobj; 1183 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1184 sym_hashes = elf_sym_hashes (abfd); 1185 local_got_refcounts = elf_local_got_refcounts (abfd); 1186 1187 sgot = NULL; 1188 srelgot = NULL; 1189 1190 rel_end = relocs + sec->reloc_count; 1191 for (rel = relocs; rel < rel_end; rel++) 1192 { 1193 unsigned long r_symndx; 1194 struct elf_link_hash_entry *h; 1195 1196 r_symndx = ELF32_R_SYM (rel->r_info); 1197 if (r_symndx < symtab_hdr->sh_info) 1198 h = NULL; 1199 else 1200 { 1201 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1202 } 1203 1204 switch (ELF32_R_TYPE (rel->r_info)) 1205 { 1206 /* This relocation describes the C++ object vtable hierarchy. 1207 Reconstruct it for later use during GC. */ 1208 case R_BFIN_GNU_VTINHERIT: 1209 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 1210 return FALSE; 1211 break; 1212 1213 /* This relocation describes which C++ vtable entries 1214 are actually used. Record for later use during GC. */ 1215 case R_BFIN_GNU_VTENTRY: 1216 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 1217 return FALSE; 1218 break; 1219 1220 case R_BFIN_GOT: 1221 if (h != NULL 1222 && strcmp (h->root.root.string, "__GLOBAL_OFFSET_TABLE_") == 0) 1223 break; 1224 /* Fall through. */ 1225 1226 if (dynobj == NULL) 1227 { 1228 /* Create the .got section. */ 1229 elf_hash_table (info)->dynobj = dynobj = abfd; 1230 if (!_bfd_elf_create_got_section (dynobj, info)) 1231 return FALSE; 1232 } 1233 1234 sgot = elf_hash_table (info)->sgot; 1235 srelgot = elf_hash_table (info)->srelgot; 1236 BFD_ASSERT (sgot != NULL); 1237 1238 if (h != NULL) 1239 { 1240 if (h->got.refcount == 0) 1241 { 1242 /* Make sure this symbol is output as a dynamic symbol. */ 1243 if (h->dynindx == -1 && !h->forced_local) 1244 { 1245 if (!bfd_elf_link_record_dynamic_symbol (info, h)) 1246 return FALSE; 1247 } 1248 1249 /* Allocate space in the .got section. */ 1250 sgot->size += 4; 1251 /* Allocate relocation space. */ 1252 srelgot->size += sizeof (Elf32_External_Rela); 1253 } 1254 h->got.refcount++; 1255 } 1256 else 1257 { 1258 /* This is a global offset table entry for a local symbol. */ 1259 if (local_got_refcounts == NULL) 1260 { 1261 bfd_size_type size; 1262 1263 size = symtab_hdr->sh_info; 1264 size *= sizeof (bfd_signed_vma); 1265 local_got_refcounts = ((bfd_signed_vma *) 1266 bfd_zalloc (abfd, size)); 1267 if (local_got_refcounts == NULL) 1268 return FALSE; 1269 elf_local_got_refcounts (abfd) = local_got_refcounts; 1270 } 1271 if (local_got_refcounts[r_symndx] == 0) 1272 { 1273 sgot->size += 4; 1274 if (bfd_link_pic (info)) 1275 { 1276 /* If we are generating a shared object, we need to 1277 output a R_68K_RELATIVE reloc so that the dynamic 1278 linker can adjust this GOT entry. */ 1279 srelgot->size += sizeof (Elf32_External_Rela); 1280 } 1281 } 1282 local_got_refcounts[r_symndx]++; 1283 } 1284 break; 1285 1286 default: 1287 break; 1288 } 1289 } 1290 1291 return TRUE; 1292 } 1293 1294 static enum elf_reloc_type_class 1295 elf32_bfin_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, 1296 const asection *rel_sec ATTRIBUTE_UNUSED, 1297 const Elf_Internal_Rela * rela) 1298 { 1299 switch ((int) ELF32_R_TYPE (rela->r_info)) 1300 { 1301 default: 1302 return reloc_class_normal; 1303 } 1304 } 1305 1306 static bfd_reloc_status_type 1308 bfin_final_link_relocate (Elf_Internal_Rela *rel, reloc_howto_type *howto, 1309 bfd *input_bfd, asection *input_section, 1310 bfd_byte *contents, bfd_vma address, 1311 bfd_vma value, bfd_vma addend) 1312 { 1313 int r_type = ELF32_R_TYPE (rel->r_info); 1314 1315 if (r_type == R_BFIN_PCREL24 || r_type == R_BFIN_PCREL24_JUMP_L) 1316 { 1317 bfd_reloc_status_type r = bfd_reloc_ok; 1318 bfd_vma x; 1319 1320 if (address > bfd_get_section_limit (input_bfd, input_section)) 1321 return bfd_reloc_outofrange; 1322 1323 value += addend; 1324 1325 /* Perform usual pc-relative correction. */ 1326 value -= input_section->output_section->vma + input_section->output_offset; 1327 value -= address; 1328 1329 /* We are getting reloc_entry->address 2 byte off from 1330 the start of instruction. Assuming absolute postion 1331 of the reloc data. But, following code had been written assuming 1332 reloc address is starting at begining of instruction. 1333 To compensate that I have increased the value of 1334 relocation by 1 (effectively 2) and used the addr -2 instead of addr. */ 1335 1336 value += 2; 1337 address -= 2; 1338 1339 if ((value & 0xFF000000) != 0 1340 && (value & 0xFF000000) != 0xFF000000) 1341 r = bfd_reloc_overflow; 1342 1343 value >>= 1; 1344 1345 x = bfd_get_16 (input_bfd, contents + address); 1346 x = (x & 0xff00) | ((value >> 16) & 0xff); 1347 bfd_put_16 (input_bfd, x, contents + address); 1348 1349 x = bfd_get_16 (input_bfd, contents + address + 2); 1350 x = value & 0xFFFF; 1351 bfd_put_16 (input_bfd, x, contents + address + 2); 1352 return r; 1353 } 1354 1355 return _bfd_final_link_relocate (howto, input_bfd, input_section, contents, 1356 rel->r_offset, value, addend); 1357 1358 } 1359 1360 static bfd_boolean 1361 bfin_relocate_section (bfd * output_bfd, 1362 struct bfd_link_info *info, 1363 bfd * input_bfd, 1364 asection * input_section, 1365 bfd_byte * contents, 1366 Elf_Internal_Rela * relocs, 1367 Elf_Internal_Sym * local_syms, 1368 asection ** local_sections) 1369 { 1370 bfd *dynobj; 1371 Elf_Internal_Shdr *symtab_hdr; 1372 struct elf_link_hash_entry **sym_hashes; 1373 bfd_vma *local_got_offsets; 1374 asection *sgot; 1375 Elf_Internal_Rela *rel; 1376 Elf_Internal_Rela *relend; 1377 int i = 0; 1378 1379 dynobj = elf_hash_table (info)->dynobj; 1380 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1381 sym_hashes = elf_sym_hashes (input_bfd); 1382 local_got_offsets = elf_local_got_offsets (input_bfd); 1383 1384 sgot = NULL; 1385 1386 rel = relocs; 1387 relend = relocs + input_section->reloc_count; 1388 for (; rel < relend; rel++, i++) 1389 { 1390 int r_type; 1391 reloc_howto_type *howto; 1392 unsigned long r_symndx; 1393 struct elf_link_hash_entry *h; 1394 Elf_Internal_Sym *sym; 1395 asection *sec; 1396 bfd_vma relocation = 0; 1397 bfd_boolean unresolved_reloc; 1398 bfd_reloc_status_type r; 1399 bfd_vma address; 1400 1401 r_type = ELF32_R_TYPE (rel->r_info); 1402 if (r_type < 0 || r_type >= 243) 1403 { 1404 bfd_set_error (bfd_error_bad_value); 1405 return FALSE; 1406 } 1407 1408 if (r_type == R_BFIN_GNU_VTENTRY 1409 || r_type == R_BFIN_GNU_VTINHERIT) 1410 continue; 1411 1412 howto = bfin_reloc_type_lookup (input_bfd, r_type); 1413 if (howto == NULL) 1414 { 1415 bfd_set_error (bfd_error_bad_value); 1416 return FALSE; 1417 } 1418 r_symndx = ELF32_R_SYM (rel->r_info); 1419 1420 h = NULL; 1421 sym = NULL; 1422 sec = NULL; 1423 unresolved_reloc = FALSE; 1424 1425 if (r_symndx < symtab_hdr->sh_info) 1426 { 1427 sym = local_syms + r_symndx; 1428 sec = local_sections[r_symndx]; 1429 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 1430 } 1431 else 1432 { 1433 bfd_boolean warned, ignored; 1434 1435 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 1436 r_symndx, symtab_hdr, sym_hashes, 1437 h, sec, relocation, 1438 unresolved_reloc, warned, ignored); 1439 } 1440 1441 if (sec != NULL && discarded_section (sec)) 1442 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 1443 rel, 1, relend, howto, 0, contents); 1444 1445 if (bfd_link_relocatable (info)) 1446 continue; 1447 1448 address = rel->r_offset; 1449 1450 /* Then, process normally. */ 1451 switch (r_type) 1452 { 1453 case R_BFIN_GNU_VTINHERIT: 1454 case R_BFIN_GNU_VTENTRY: 1455 return bfd_reloc_ok; 1456 1457 case R_BFIN_GOT: 1458 /* Relocation is to the address of the entry for this symbol 1459 in the global offset table. */ 1460 if (h != NULL 1461 && strcmp (h->root.root.string, "__GLOBAL_OFFSET_TABLE_") == 0) 1462 goto do_default; 1463 /* Fall through. */ 1464 /* Relocation is the offset of the entry for this symbol in 1465 the global offset table. */ 1466 1467 { 1468 bfd_vma off; 1469 1470 if (dynobj == NULL) 1471 { 1472 /* Create the .got section. */ 1473 elf_hash_table (info)->dynobj = dynobj = output_bfd; 1474 if (!_bfd_elf_create_got_section (dynobj, info)) 1475 return FALSE; 1476 } 1477 1478 sgot = elf_hash_table (info)->sgot; 1479 BFD_ASSERT (sgot != NULL); 1480 1481 if (h != NULL) 1482 { 1483 bfd_boolean dyn; 1484 1485 off = h->got.offset; 1486 BFD_ASSERT (off != (bfd_vma) - 1); 1487 dyn = elf_hash_table (info)->dynamic_sections_created; 1488 1489 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 1490 bfd_link_pic (info), 1491 h) 1492 || (bfd_link_pic (info) 1493 && (info->symbolic 1494 || h->dynindx == -1 1495 || h->forced_local) 1496 && h->def_regular)) 1497 { 1498 /* This is actually a static link, or it is a 1499 -Bsymbolic link and the symbol is defined 1500 locally, or the symbol was forced to be local 1501 because of a version file.. We must initialize 1502 this entry in the global offset table. Since 1503 the offset must always be a multiple of 4, we 1504 use the least significant bit to record whether 1505 we have initialized it already. 1506 1507 When doing a dynamic link, we create a .rela.got 1508 relocation entry to initialize the value. This 1509 is done in the finish_dynamic_symbol routine. */ 1510 if ((off & 1) != 0) 1511 off &= ~1; 1512 else 1513 { 1514 bfd_put_32 (output_bfd, relocation, 1515 sgot->contents + off); 1516 h->got.offset |= 1; 1517 } 1518 } 1519 else 1520 unresolved_reloc = FALSE; 1521 } 1522 else 1523 { 1524 BFD_ASSERT (local_got_offsets != NULL); 1525 off = local_got_offsets[r_symndx]; 1526 BFD_ASSERT (off != (bfd_vma) - 1); 1527 1528 /* The offset must always be a multiple of 4. We use 1529 the least significant bit to record whether we have 1530 already generated the necessary reloc. */ 1531 if ((off & 1) != 0) 1532 off &= ~1; 1533 else 1534 { 1535 bfd_put_32 (output_bfd, relocation, sgot->contents + off); 1536 1537 if (bfd_link_pic (info)) 1538 { 1539 asection *s; 1540 Elf_Internal_Rela outrel; 1541 bfd_byte *loc; 1542 1543 s = elf_hash_table (info)->srelgot; 1544 BFD_ASSERT (s != NULL); 1545 1546 outrel.r_offset = (sgot->output_section->vma 1547 + sgot->output_offset + off); 1548 outrel.r_info = 1549 ELF32_R_INFO (0, R_BFIN_PCREL24); 1550 outrel.r_addend = relocation; 1551 loc = s->contents; 1552 loc += 1553 s->reloc_count++ * sizeof (Elf32_External_Rela); 1554 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 1555 } 1556 1557 local_got_offsets[r_symndx] |= 1; 1558 } 1559 } 1560 1561 relocation = sgot->output_offset + off; 1562 rel->r_addend = 0; 1563 /* bfin : preg = [preg + 17bitdiv4offset] relocation is div by 4. */ 1564 relocation /= 4; 1565 } 1566 goto do_default; 1567 1568 default: 1569 do_default: 1570 r = bfin_final_link_relocate (rel, howto, input_bfd, input_section, 1571 contents, address, 1572 relocation, rel->r_addend); 1573 1574 break; 1575 } 1576 1577 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 1578 because such sections are not SEC_ALLOC and thus ld.so will 1579 not process them. */ 1580 if (unresolved_reloc 1581 && !((input_section->flags & SEC_DEBUGGING) != 0 && h->def_dynamic) 1582 && _bfd_elf_section_offset (output_bfd, info, input_section, 1583 rel->r_offset) != (bfd_vma) -1) 1584 { 1585 _bfd_error_handler 1586 /* xgettext:c-format */ 1587 (_("%pB(%pA+%#" PRIx64 "): " 1588 "unresolvable relocation against symbol `%s'"), 1589 input_bfd, input_section, (uint64_t) rel->r_offset, 1590 h->root.root.string); 1591 return FALSE; 1592 } 1593 1594 if (r != bfd_reloc_ok) 1595 { 1596 const char *name; 1597 1598 if (h != NULL) 1599 name = h->root.root.string; 1600 else 1601 { 1602 name = bfd_elf_string_from_elf_section (input_bfd, 1603 symtab_hdr->sh_link, 1604 sym->st_name); 1605 if (name == NULL) 1606 return FALSE; 1607 if (*name == '\0') 1608 name = bfd_section_name (sec); 1609 } 1610 1611 if (r == bfd_reloc_overflow) 1612 (*info->callbacks->reloc_overflow) 1613 (info, (h ? &h->root : NULL), name, howto->name, 1614 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 1615 else 1616 { 1617 _bfd_error_handler 1618 /* xgettext:c-format */ 1619 (_("%pB(%pA+%#" PRIx64 "): reloc against `%s': error %d"), 1620 input_bfd, input_section, (uint64_t) rel->r_offset, 1621 name, (int) r); 1622 return FALSE; 1623 } 1624 } 1625 } 1626 1627 return TRUE; 1628 } 1629 1630 static asection * 1631 bfin_gc_mark_hook (asection * sec, 1632 struct bfd_link_info *info, 1633 Elf_Internal_Rela * rel, 1634 struct elf_link_hash_entry *h, 1635 Elf_Internal_Sym * sym) 1636 { 1637 if (h != NULL) 1638 switch (ELF32_R_TYPE (rel->r_info)) 1639 { 1640 case R_BFIN_GNU_VTINHERIT: 1641 case R_BFIN_GNU_VTENTRY: 1642 return NULL; 1643 } 1644 1645 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 1646 } 1647 1648 extern const bfd_target bfin_elf32_fdpic_vec; 1650 #define IS_FDPIC(bfd) ((bfd)->xvec == &bfin_elf32_fdpic_vec) 1651 1652 /* An extension of the elf hash table data structure, 1653 containing some additional Blackfin-specific data. */ 1654 struct bfinfdpic_elf_link_hash_table 1655 { 1656 struct elf_link_hash_table elf; 1657 1658 /* A pointer to the .rofixup section. */ 1659 asection *sgotfixup; 1660 /* GOT base offset. */ 1661 bfd_vma got0; 1662 /* Location of the first non-lazy PLT entry, i.e., the number of 1663 bytes taken by lazy PLT entries. */ 1664 bfd_vma plt0; 1665 /* A hash table holding information about which symbols were 1666 referenced with which PIC-related relocations. */ 1667 struct htab *relocs_info; 1668 /* Summary reloc information collected by 1669 _bfinfdpic_count_got_plt_entries. */ 1670 struct _bfinfdpic_dynamic_got_info *g; 1671 }; 1672 1673 /* Get the Blackfin ELF linker hash table from a link_info structure. */ 1674 1675 #define bfinfdpic_hash_table(info) \ 1676 (elf_hash_table_id ((struct elf_link_hash_table *) ((info)->hash)) \ 1677 == BFIN_ELF_DATA ? ((struct bfinfdpic_elf_link_hash_table *) ((info)->hash)) : NULL) 1678 1679 #define bfinfdpic_got_section(info) \ 1680 (bfinfdpic_hash_table (info)->elf.sgot) 1681 #define bfinfdpic_gotrel_section(info) \ 1682 (bfinfdpic_hash_table (info)->elf.srelgot) 1683 #define bfinfdpic_gotfixup_section(info) \ 1684 (bfinfdpic_hash_table (info)->sgotfixup) 1685 #define bfinfdpic_plt_section(info) \ 1686 (bfinfdpic_hash_table (info)->elf.splt) 1687 #define bfinfdpic_pltrel_section(info) \ 1688 (bfinfdpic_hash_table (info)->elf.srelplt) 1689 #define bfinfdpic_relocs_info(info) \ 1690 (bfinfdpic_hash_table (info)->relocs_info) 1691 #define bfinfdpic_got_initial_offset(info) \ 1692 (bfinfdpic_hash_table (info)->got0) 1693 #define bfinfdpic_plt_initial_offset(info) \ 1694 (bfinfdpic_hash_table (info)->plt0) 1695 #define bfinfdpic_dynamic_got_plt_info(info) \ 1696 (bfinfdpic_hash_table (info)->g) 1697 1698 /* The name of the dynamic interpreter. This is put in the .interp 1699 section. */ 1700 1701 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1" 1702 1703 #define DEFAULT_STACK_SIZE 0x20000 1704 1705 /* This structure is used to collect the number of entries present in 1706 each addressable range of the got. */ 1707 struct _bfinfdpic_dynamic_got_info 1708 { 1709 /* Several bits of information about the current link. */ 1710 struct bfd_link_info *info; 1711 /* Total size needed for GOT entries within the 18- or 32-bit 1712 ranges. */ 1713 bfd_vma got17m4, gothilo; 1714 /* Total size needed for function descriptor entries within the 18- 1715 or 32-bit ranges. */ 1716 bfd_vma fd17m4, fdhilo; 1717 /* Total size needed function descriptor entries referenced in PLT 1718 entries, that would be profitable to place in offsets close to 1719 the PIC register. */ 1720 bfd_vma fdplt; 1721 /* Total size needed by lazy PLT entries. */ 1722 bfd_vma lzplt; 1723 /* Number of relocations carried over from input object files. */ 1724 unsigned long relocs; 1725 /* Number of fixups introduced by relocations in input object files. */ 1726 unsigned long fixups; 1727 }; 1728 1729 /* Create a Blackfin ELF linker hash table. */ 1730 1731 static struct bfd_link_hash_table * 1732 bfinfdpic_elf_link_hash_table_create (bfd *abfd) 1733 { 1734 struct bfinfdpic_elf_link_hash_table *ret; 1735 bfd_size_type amt = sizeof (struct bfinfdpic_elf_link_hash_table); 1736 1737 ret = bfd_zmalloc (amt); 1738 if (ret == NULL) 1739 return NULL; 1740 1741 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, 1742 _bfd_elf_link_hash_newfunc, 1743 sizeof (struct elf_link_hash_entry), 1744 BFIN_ELF_DATA)) 1745 { 1746 free (ret); 1747 return NULL; 1748 } 1749 1750 return &ret->elf.root; 1751 } 1752 1753 /* Decide whether a reference to a symbol can be resolved locally or 1754 not. If the symbol is protected, we want the local address, but 1755 its function descriptor must be assigned by the dynamic linker. */ 1756 #define BFINFDPIC_SYM_LOCAL(INFO, H) \ 1757 (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \ 1758 || ! elf_hash_table (INFO)->dynamic_sections_created) 1759 #define BFINFDPIC_FUNCDESC_LOCAL(INFO, H) \ 1760 ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created) 1761 1762 /* This structure collects information on what kind of GOT, PLT or 1763 function descriptors are required by relocations that reference a 1764 certain symbol. */ 1765 struct bfinfdpic_relocs_info 1766 { 1767 /* The index of the symbol, as stored in the relocation r_info, if 1768 we have a local symbol; -1 otherwise. */ 1769 long symndx; 1770 union 1771 { 1772 /* The input bfd in which the symbol is defined, if it's a local 1773 symbol. */ 1774 bfd *abfd; 1775 /* If symndx == -1, the hash table entry corresponding to a global 1776 symbol (even if it turns out to bind locally, in which case it 1777 should ideally be replaced with section's symndx + addend). */ 1778 struct elf_link_hash_entry *h; 1779 } d; 1780 /* The addend of the relocation that references the symbol. */ 1781 bfd_vma addend; 1782 1783 /* The fields above are used to identify an entry. The fields below 1784 contain information on how an entry is used and, later on, which 1785 locations it was assigned. */ 1786 /* The following 2 fields record whether the symbol+addend above was 1787 ever referenced with a GOT relocation. The 17M4 suffix indicates a 1788 GOT17M4 relocation; hilo is used for GOTLO/GOTHI pairs. */ 1789 unsigned got17m4; 1790 unsigned gothilo; 1791 /* Whether a FUNCDESC relocation references symbol+addend. */ 1792 unsigned fd; 1793 /* Whether a FUNCDESC_GOT relocation references symbol+addend. */ 1794 unsigned fdgot17m4; 1795 unsigned fdgothilo; 1796 /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend. */ 1797 unsigned fdgoff17m4; 1798 unsigned fdgoffhilo; 1799 /* Whether symbol+addend is referenced with GOTOFF17M4, GOTOFFLO or 1800 GOTOFFHI relocations. The addend doesn't really matter, since we 1801 envision that this will only be used to check whether the symbol 1802 is mapped to the same segment as the got. */ 1803 unsigned gotoff; 1804 /* Whether symbol+addend is referenced by a LABEL24 relocation. */ 1805 unsigned call; 1806 /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE 1807 relocation. */ 1808 unsigned sym; 1809 /* Whether we need a PLT entry for a symbol. Should be implied by 1810 something like: 1811 (call && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h)) */ 1812 unsigned plt:1; 1813 /* Whether a function descriptor should be created in this link unit 1814 for symbol+addend. Should be implied by something like: 1815 (plt || fdgotoff17m4 || fdgotofflohi 1816 || ((fd || fdgot17m4 || fdgothilo) 1817 && (symndx != -1 || BFINFDPIC_FUNCDESC_LOCAL (info, d.h)))) */ 1818 unsigned privfd:1; 1819 /* Whether a lazy PLT entry is needed for this symbol+addend. 1820 Should be implied by something like: 1821 (privfd && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h) 1822 && ! (info->flags & DF_BIND_NOW)) */ 1823 unsigned lazyplt:1; 1824 /* Whether we've already emitted GOT relocations and PLT entries as 1825 needed for this symbol. */ 1826 unsigned done:1; 1827 1828 /* The number of R_BFIN_BYTE4_DATA, R_BFIN_FUNCDESC and R_BFIN_FUNCDESC_VALUE 1829 relocations referencing the symbol. */ 1830 unsigned relocs32, relocsfd, relocsfdv; 1831 1832 /* The number of .rofixups entries and dynamic relocations allocated 1833 for this symbol, minus any that might have already been used. */ 1834 unsigned fixups, dynrelocs; 1835 1836 /* The offsets of the GOT entries assigned to symbol+addend, to the 1837 function descriptor's address, and to a function descriptor, 1838 respectively. Should be zero if unassigned. The offsets are 1839 counted from the value that will be assigned to the PIC register, 1840 not from the beginning of the .got section. */ 1841 bfd_signed_vma got_entry, fdgot_entry, fd_entry; 1842 /* The offsets of the PLT entries assigned to symbol+addend, 1843 non-lazy and lazy, respectively. If unassigned, should be 1844 (bfd_vma)-1. */ 1845 bfd_vma plt_entry, lzplt_entry; 1846 }; 1847 1848 /* Compute a hash with the key fields of an bfinfdpic_relocs_info entry. */ 1849 static hashval_t 1850 bfinfdpic_relocs_info_hash (const void *entry_) 1851 { 1852 const struct bfinfdpic_relocs_info *entry = entry_; 1853 1854 return (entry->symndx == -1 1855 ? (long) entry->d.h->root.root.hash 1856 : entry->symndx + (long) entry->d.abfd->id * 257) + entry->addend; 1857 } 1858 1859 /* Test whether the key fields of two bfinfdpic_relocs_info entries are 1860 identical. */ 1861 static int 1862 bfinfdpic_relocs_info_eq (const void *entry1, const void *entry2) 1863 { 1864 const struct bfinfdpic_relocs_info *e1 = entry1; 1865 const struct bfinfdpic_relocs_info *e2 = entry2; 1866 1867 return e1->symndx == e2->symndx && e1->addend == e2->addend 1868 && (e1->symndx == -1 ? e1->d.h == e2->d.h : e1->d.abfd == e2->d.abfd); 1869 } 1870 1871 /* Find or create an entry in a hash table HT that matches the key 1872 fields of the given ENTRY. If it's not found, memory for a new 1873 entry is allocated in ABFD's obstack. */ 1874 static struct bfinfdpic_relocs_info * 1875 bfinfdpic_relocs_info_find (struct htab *ht, 1876 bfd *abfd, 1877 const struct bfinfdpic_relocs_info *entry, 1878 enum insert_option insert) 1879 { 1880 struct bfinfdpic_relocs_info **loc; 1881 1882 if (!ht) 1883 return NULL; 1884 1885 loc = (struct bfinfdpic_relocs_info **) htab_find_slot (ht, entry, insert); 1886 1887 if (! loc) 1888 return NULL; 1889 1890 if (*loc) 1891 return *loc; 1892 1893 *loc = bfd_zalloc (abfd, sizeof (**loc)); 1894 1895 if (! *loc) 1896 return *loc; 1897 1898 (*loc)->symndx = entry->symndx; 1899 (*loc)->d = entry->d; 1900 (*loc)->addend = entry->addend; 1901 (*loc)->plt_entry = (bfd_vma)-1; 1902 (*loc)->lzplt_entry = (bfd_vma)-1; 1903 1904 return *loc; 1905 } 1906 1907 /* Obtain the address of the entry in HT associated with H's symbol + 1908 addend, creating a new entry if none existed. ABFD is only used 1909 for memory allocation purposes. */ 1910 inline static struct bfinfdpic_relocs_info * 1911 bfinfdpic_relocs_info_for_global (struct htab *ht, 1912 bfd *abfd, 1913 struct elf_link_hash_entry *h, 1914 bfd_vma addend, 1915 enum insert_option insert) 1916 { 1917 struct bfinfdpic_relocs_info entry; 1918 1919 entry.symndx = -1; 1920 entry.d.h = h; 1921 entry.addend = addend; 1922 1923 return bfinfdpic_relocs_info_find (ht, abfd, &entry, insert); 1924 } 1925 1926 /* Obtain the address of the entry in HT associated with the SYMNDXth 1927 local symbol of the input bfd ABFD, plus the addend, creating a new 1928 entry if none existed. */ 1929 inline static struct bfinfdpic_relocs_info * 1930 bfinfdpic_relocs_info_for_local (struct htab *ht, 1931 bfd *abfd, 1932 long symndx, 1933 bfd_vma addend, 1934 enum insert_option insert) 1935 { 1936 struct bfinfdpic_relocs_info entry; 1937 1938 entry.symndx = symndx; 1939 entry.d.abfd = abfd; 1940 entry.addend = addend; 1941 1942 return bfinfdpic_relocs_info_find (ht, abfd, &entry, insert); 1943 } 1944 1945 /* Merge fields set by check_relocs() of two entries that end up being 1946 mapped to the same (presumably global) symbol. */ 1947 1948 inline static void 1949 bfinfdpic_pic_merge_early_relocs_info (struct bfinfdpic_relocs_info *e2, 1950 struct bfinfdpic_relocs_info const *e1) 1951 { 1952 e2->got17m4 |= e1->got17m4; 1953 e2->gothilo |= e1->gothilo; 1954 e2->fd |= e1->fd; 1955 e2->fdgot17m4 |= e1->fdgot17m4; 1956 e2->fdgothilo |= e1->fdgothilo; 1957 e2->fdgoff17m4 |= e1->fdgoff17m4; 1958 e2->fdgoffhilo |= e1->fdgoffhilo; 1959 e2->gotoff |= e1->gotoff; 1960 e2->call |= e1->call; 1961 e2->sym |= e1->sym; 1962 } 1963 1964 /* Every block of 65535 lazy PLT entries shares a single call to the 1965 resolver, inserted in the 32768th lazy PLT entry (i.e., entry # 1966 32767, counting from 0). All other lazy PLT entries branch to it 1967 in a single instruction. */ 1968 1969 #define LZPLT_RESOLVER_EXTRA 10 1970 #define LZPLT_NORMAL_SIZE 6 1971 #define LZPLT_ENTRIES 1362 1972 1973 #define BFINFDPIC_LZPLT_BLOCK_SIZE ((bfd_vma) LZPLT_NORMAL_SIZE * LZPLT_ENTRIES + LZPLT_RESOLVER_EXTRA) 1974 #define BFINFDPIC_LZPLT_RESOLV_LOC (LZPLT_NORMAL_SIZE * LZPLT_ENTRIES / 2) 1975 1976 /* Add a dynamic relocation to the SRELOC section. */ 1977 1978 inline static bfd_vma 1979 _bfinfdpic_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset, 1980 int reloc_type, long dynindx, bfd_vma addend, 1981 struct bfinfdpic_relocs_info *entry) 1982 { 1983 Elf_Internal_Rela outrel; 1984 bfd_vma reloc_offset; 1985 1986 outrel.r_offset = offset; 1987 outrel.r_info = ELF32_R_INFO (dynindx, reloc_type); 1988 outrel.r_addend = addend; 1989 1990 reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rel); 1991 BFD_ASSERT (reloc_offset < sreloc->size); 1992 bfd_elf32_swap_reloc_out (output_bfd, &outrel, 1993 sreloc->contents + reloc_offset); 1994 sreloc->reloc_count++; 1995 1996 /* If the entry's index is zero, this relocation was probably to a 1997 linkonce section that got discarded. We reserved a dynamic 1998 relocation, but it was for another entry than the one we got at 1999 the time of emitting the relocation. Unfortunately there's no 2000 simple way for us to catch this situation, since the relocation 2001 is cleared right before calling relocate_section, at which point 2002 we no longer know what the relocation used to point to. */ 2003 if (entry->symndx) 2004 { 2005 BFD_ASSERT (entry->dynrelocs > 0); 2006 entry->dynrelocs--; 2007 } 2008 2009 return reloc_offset; 2010 } 2011 2012 /* Add a fixup to the ROFIXUP section. */ 2013 2014 static bfd_vma 2015 _bfinfdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma offset, 2016 struct bfinfdpic_relocs_info *entry) 2017 { 2018 bfd_vma fixup_offset; 2019 2020 if (rofixup->flags & SEC_EXCLUDE) 2021 return -1; 2022 2023 fixup_offset = rofixup->reloc_count * 4; 2024 if (rofixup->contents) 2025 { 2026 BFD_ASSERT (fixup_offset < rofixup->size); 2027 bfd_put_32 (output_bfd, offset, rofixup->contents + fixup_offset); 2028 } 2029 rofixup->reloc_count++; 2030 2031 if (entry && entry->symndx) 2032 { 2033 /* See discussion about symndx == 0 in _bfinfdpic_add_dyn_reloc 2034 above. */ 2035 BFD_ASSERT (entry->fixups > 0); 2036 entry->fixups--; 2037 } 2038 2039 return fixup_offset; 2040 } 2041 2042 /* Find the segment number in which OSEC, and output section, is 2043 located. */ 2044 2045 static unsigned 2046 _bfinfdpic_osec_to_segment (bfd *output_bfd, asection *osec) 2047 { 2048 Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section (output_bfd, osec); 2049 2050 return (p != NULL) ? p - elf_tdata (output_bfd)->phdr : -1; 2051 } 2052 2053 inline static bfd_boolean 2054 _bfinfdpic_osec_readonly_p (bfd *output_bfd, asection *osec) 2055 { 2056 unsigned seg = _bfinfdpic_osec_to_segment (output_bfd, osec); 2057 2058 return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W); 2059 } 2060 2061 /* Generate relocations for GOT entries, function descriptors, and 2062 code for PLT and lazy PLT entries. */ 2063 2064 inline static bfd_boolean 2065 _bfinfdpic_emit_got_relocs_plt_entries (struct bfinfdpic_relocs_info *entry, 2066 bfd *output_bfd, 2067 struct bfd_link_info *info, 2068 asection *sec, 2069 Elf_Internal_Sym *sym, 2070 bfd_vma addend) 2071 { 2072 bfd_vma fd_lazy_rel_offset = (bfd_vma) -1; 2073 int dynindx = -1; 2074 2075 if (entry->done) 2076 return TRUE; 2077 entry->done = 1; 2078 2079 if (entry->got_entry || entry->fdgot_entry || entry->fd_entry) 2080 { 2081 /* If the symbol is dynamic, consider it for dynamic 2082 relocations, otherwise decay to section + offset. */ 2083 if (entry->symndx == -1 && entry->d.h->dynindx != -1) 2084 dynindx = entry->d.h->dynindx; 2085 else 2086 { 2087 if (sec 2088 && sec->output_section 2089 && ! bfd_is_abs_section (sec->output_section) 2090 && ! bfd_is_und_section (sec->output_section)) 2091 dynindx = elf_section_data (sec->output_section)->dynindx; 2092 else 2093 dynindx = 0; 2094 } 2095 } 2096 2097 /* Generate relocation for GOT entry pointing to the symbol. */ 2098 if (entry->got_entry) 2099 { 2100 int idx = dynindx; 2101 bfd_vma ad = addend; 2102 2103 /* If the symbol is dynamic but binds locally, use 2104 section+offset. */ 2105 if (sec && (entry->symndx != -1 2106 || BFINFDPIC_SYM_LOCAL (info, entry->d.h))) 2107 { 2108 if (entry->symndx == -1) 2109 ad += entry->d.h->root.u.def.value; 2110 else 2111 ad += sym->st_value; 2112 ad += sec->output_offset; 2113 if (sec->output_section && elf_section_data (sec->output_section)) 2114 idx = elf_section_data (sec->output_section)->dynindx; 2115 else 2116 idx = 0; 2117 } 2118 2119 /* If we're linking an executable at a fixed address, we can 2120 omit the dynamic relocation as long as the symbol is local to 2121 this module. */ 2122 if (bfd_link_pde (info) 2123 && (entry->symndx != -1 2124 || BFINFDPIC_SYM_LOCAL (info, entry->d.h))) 2125 { 2126 if (sec) 2127 ad += sec->output_section->vma; 2128 if (entry->symndx != -1 2129 || entry->d.h->root.type != bfd_link_hash_undefweak) 2130 _bfinfdpic_add_rofixup (output_bfd, 2131 bfinfdpic_gotfixup_section (info), 2132 bfinfdpic_got_section (info)->output_section 2133 ->vma 2134 + bfinfdpic_got_section (info)->output_offset 2135 + bfinfdpic_got_initial_offset (info) 2136 + entry->got_entry, entry); 2137 } 2138 else 2139 _bfinfdpic_add_dyn_reloc (output_bfd, bfinfdpic_gotrel_section (info), 2140 _bfd_elf_section_offset 2141 (output_bfd, info, 2142 bfinfdpic_got_section (info), 2143 bfinfdpic_got_initial_offset (info) 2144 + entry->got_entry) 2145 + bfinfdpic_got_section (info) 2146 ->output_section->vma 2147 + bfinfdpic_got_section (info)->output_offset, 2148 R_BFIN_BYTE4_DATA, idx, ad, entry); 2149 2150 bfd_put_32 (output_bfd, ad, 2151 bfinfdpic_got_section (info)->contents 2152 + bfinfdpic_got_initial_offset (info) 2153 + entry->got_entry); 2154 } 2155 2156 /* Generate relocation for GOT entry pointing to a canonical 2157 function descriptor. */ 2158 if (entry->fdgot_entry) 2159 { 2160 int reloc, idx; 2161 bfd_vma ad = 0; 2162 2163 if (! (entry->symndx == -1 2164 && entry->d.h->root.type == bfd_link_hash_undefweak 2165 && BFINFDPIC_SYM_LOCAL (info, entry->d.h))) 2166 { 2167 /* If the symbol is dynamic and there may be dynamic symbol 2168 resolution because we are, or are linked with, a shared 2169 library, emit a FUNCDESC relocation such that the dynamic 2170 linker will allocate the function descriptor. If the 2171 symbol needs a non-local function descriptor but binds 2172 locally (e.g., its visibility is protected, emit a 2173 dynamic relocation decayed to section+offset. */ 2174 if (entry->symndx == -1 2175 && ! BFINFDPIC_FUNCDESC_LOCAL (info, entry->d.h) 2176 && BFINFDPIC_SYM_LOCAL (info, entry->d.h) 2177 && !bfd_link_pde (info)) 2178 { 2179 reloc = R_BFIN_FUNCDESC; 2180 idx = elf_section_data (entry->d.h->root.u.def.section 2181 ->output_section)->dynindx; 2182 ad = entry->d.h->root.u.def.section->output_offset 2183 + entry->d.h->root.u.def.value; 2184 } 2185 else if (entry->symndx == -1 2186 && ! BFINFDPIC_FUNCDESC_LOCAL (info, entry->d.h)) 2187 { 2188 reloc = R_BFIN_FUNCDESC; 2189 idx = dynindx; 2190 ad = addend; 2191 if (ad) 2192 return FALSE; 2193 } 2194 else 2195 { 2196 /* Otherwise, we know we have a private function descriptor, 2197 so reference it directly. */ 2198 if (elf_hash_table (info)->dynamic_sections_created) 2199 BFD_ASSERT (entry->privfd); 2200 reloc = R_BFIN_BYTE4_DATA; 2201 idx = elf_section_data (bfinfdpic_got_section (info) 2202 ->output_section)->dynindx; 2203 ad = bfinfdpic_got_section (info)->output_offset 2204 + bfinfdpic_got_initial_offset (info) + entry->fd_entry; 2205 } 2206 2207 /* If there is room for dynamic symbol resolution, emit the 2208 dynamic relocation. However, if we're linking an 2209 executable at a fixed location, we won't have emitted a 2210 dynamic symbol entry for the got section, so idx will be 2211 zero, which means we can and should compute the address 2212 of the private descriptor ourselves. */ 2213 if (bfd_link_pde (info) 2214 && (entry->symndx != -1 2215 || BFINFDPIC_FUNCDESC_LOCAL (info, entry->d.h))) 2216 { 2217 ad += bfinfdpic_got_section (info)->output_section->vma; 2218 _bfinfdpic_add_rofixup (output_bfd, 2219 bfinfdpic_gotfixup_section (info), 2220 bfinfdpic_got_section (info) 2221 ->output_section->vma 2222 + bfinfdpic_got_section (info) 2223 ->output_offset 2224 + bfinfdpic_got_initial_offset (info) 2225 + entry->fdgot_entry, entry); 2226 } 2227 else 2228 _bfinfdpic_add_dyn_reloc (output_bfd, 2229 bfinfdpic_gotrel_section (info), 2230 _bfd_elf_section_offset 2231 (output_bfd, info, 2232 bfinfdpic_got_section (info), 2233 bfinfdpic_got_initial_offset (info) 2234 + entry->fdgot_entry) 2235 + bfinfdpic_got_section (info) 2236 ->output_section->vma 2237 + bfinfdpic_got_section (info) 2238 ->output_offset, 2239 reloc, idx, ad, entry); 2240 } 2241 2242 bfd_put_32 (output_bfd, ad, 2243 bfinfdpic_got_section (info)->contents 2244 + bfinfdpic_got_initial_offset (info) 2245 + entry->fdgot_entry); 2246 } 2247 2248 /* Generate relocation to fill in a private function descriptor in 2249 the GOT. */ 2250 if (entry->fd_entry) 2251 { 2252 int idx = dynindx; 2253 bfd_vma ad = addend; 2254 bfd_vma ofst; 2255 long lowword, highword; 2256 2257 /* If the symbol is dynamic but binds locally, use 2258 section+offset. */ 2259 if (sec && (entry->symndx != -1 2260 || BFINFDPIC_SYM_LOCAL (info, entry->d.h))) 2261 { 2262 if (entry->symndx == -1) 2263 ad += entry->d.h->root.u.def.value; 2264 else 2265 ad += sym->st_value; 2266 ad += sec->output_offset; 2267 if (sec->output_section && elf_section_data (sec->output_section)) 2268 idx = elf_section_data (sec->output_section)->dynindx; 2269 else 2270 idx = 0; 2271 } 2272 2273 /* If we're linking an executable at a fixed address, we can 2274 omit the dynamic relocation as long as the symbol is local to 2275 this module. */ 2276 if (bfd_link_pde (info) 2277 && (entry->symndx != -1 || BFINFDPIC_SYM_LOCAL (info, entry->d.h))) 2278 { 2279 if (sec) 2280 ad += sec->output_section->vma; 2281 ofst = 0; 2282 if (entry->symndx != -1 2283 || entry->d.h->root.type != bfd_link_hash_undefweak) 2284 { 2285 _bfinfdpic_add_rofixup (output_bfd, 2286 bfinfdpic_gotfixup_section (info), 2287 bfinfdpic_got_section (info) 2288 ->output_section->vma 2289 + bfinfdpic_got_section (info) 2290 ->output_offset 2291 + bfinfdpic_got_initial_offset (info) 2292 + entry->fd_entry, entry); 2293 _bfinfdpic_add_rofixup (output_bfd, 2294 bfinfdpic_gotfixup_section (info), 2295 bfinfdpic_got_section (info) 2296 ->output_section->vma 2297 + bfinfdpic_got_section (info) 2298 ->output_offset 2299 + bfinfdpic_got_initial_offset (info) 2300 + entry->fd_entry + 4, entry); 2301 } 2302 } 2303 else 2304 { 2305 ofst 2306 = _bfinfdpic_add_dyn_reloc (output_bfd, 2307 entry->lazyplt 2308 ? bfinfdpic_pltrel_section (info) 2309 : bfinfdpic_gotrel_section (info), 2310 _bfd_elf_section_offset 2311 (output_bfd, info, 2312 bfinfdpic_got_section (info), 2313 bfinfdpic_got_initial_offset (info) 2314 + entry->fd_entry) 2315 + bfinfdpic_got_section (info) 2316 ->output_section->vma 2317 + bfinfdpic_got_section (info) 2318 ->output_offset, 2319 R_BFIN_FUNCDESC_VALUE, idx, ad, entry); 2320 } 2321 2322 /* If we've omitted the dynamic relocation, just emit the fixed 2323 addresses of the symbol and of the local GOT base offset. */ 2324 if (bfd_link_pde (info) 2325 && sec 2326 && sec->output_section) 2327 { 2328 lowword = ad; 2329 highword = bfinfdpic_got_section (info)->output_section->vma 2330 + bfinfdpic_got_section (info)->output_offset 2331 + bfinfdpic_got_initial_offset (info); 2332 } 2333 else if (entry->lazyplt) 2334 { 2335 if (ad) 2336 return FALSE; 2337 2338 fd_lazy_rel_offset = ofst; 2339 2340 /* A function descriptor used for lazy or local resolving is 2341 initialized such that its high word contains the output 2342 section index in which the PLT entries are located, and 2343 the low word contains the address of the lazy PLT entry 2344 entry point, that must be within the memory region 2345 assigned to that section. */ 2346 lowword = entry->lzplt_entry + 4 2347 + bfinfdpic_plt_section (info)->output_offset 2348 + bfinfdpic_plt_section (info)->output_section->vma; 2349 highword = _bfinfdpic_osec_to_segment 2350 (output_bfd, bfinfdpic_plt_section (info)->output_section); 2351 } 2352 else 2353 { 2354 /* A function descriptor for a local function gets the index 2355 of the section. For a non-local function, it's 2356 disregarded. */ 2357 lowword = ad; 2358 if (sec == NULL 2359 || (entry->symndx == -1 && entry->d.h->dynindx != -1 2360 && entry->d.h->dynindx == idx)) 2361 highword = 0; 2362 else 2363 highword = _bfinfdpic_osec_to_segment 2364 (output_bfd, sec->output_section); 2365 } 2366 2367 bfd_put_32 (output_bfd, lowword, 2368 bfinfdpic_got_section (info)->contents 2369 + bfinfdpic_got_initial_offset (info) 2370 + entry->fd_entry); 2371 bfd_put_32 (output_bfd, highword, 2372 bfinfdpic_got_section (info)->contents 2373 + bfinfdpic_got_initial_offset (info) 2374 + entry->fd_entry + 4); 2375 } 2376 2377 /* Generate code for the PLT entry. */ 2378 if (entry->plt_entry != (bfd_vma) -1) 2379 { 2380 bfd_byte *plt_code = bfinfdpic_plt_section (info)->contents 2381 + entry->plt_entry; 2382 2383 BFD_ASSERT (entry->fd_entry); 2384 2385 /* Figure out what kind of PLT entry we need, depending on the 2386 location of the function descriptor within the GOT. */ 2387 if (entry->fd_entry >= -(1 << (18 - 1)) 2388 && entry->fd_entry + 4 < (1 << (18 - 1))) 2389 { 2390 /* P1 = [P3 + fd_entry]; P3 = [P3 + fd_entry + 4] */ 2391 bfd_put_32 (output_bfd, 2392 0xe519 | ((entry->fd_entry << 14) & 0xFFFF0000), 2393 plt_code); 2394 bfd_put_32 (output_bfd, 2395 0xe51b | (((entry->fd_entry + 4) << 14) & 0xFFFF0000), 2396 plt_code + 4); 2397 plt_code += 8; 2398 } 2399 else 2400 { 2401 /* P1.L = fd_entry; P1.H = fd_entry; 2402 P3 = P3 + P1; 2403 P1 = [P3]; 2404 P3 = [P3 + 4]; */ 2405 bfd_put_32 (output_bfd, 2406 0xe109 | (entry->fd_entry << 16), 2407 plt_code); 2408 bfd_put_32 (output_bfd, 2409 0xe149 | (entry->fd_entry & 0xFFFF0000), 2410 plt_code + 4); 2411 bfd_put_16 (output_bfd, 0x5ad9, plt_code + 8); 2412 bfd_put_16 (output_bfd, 0x9159, plt_code + 10); 2413 bfd_put_16 (output_bfd, 0xac5b, plt_code + 12); 2414 plt_code += 14; 2415 } 2416 /* JUMP (P1) */ 2417 bfd_put_16 (output_bfd, 0x0051, plt_code); 2418 } 2419 2420 /* Generate code for the lazy PLT entry. */ 2421 if (entry->lzplt_entry != (bfd_vma) -1) 2422 { 2423 bfd_byte *lzplt_code = bfinfdpic_plt_section (info)->contents 2424 + entry->lzplt_entry; 2425 bfd_vma resolverStub_addr; 2426 2427 bfd_put_32 (output_bfd, fd_lazy_rel_offset, lzplt_code); 2428 lzplt_code += 4; 2429 2430 resolverStub_addr = entry->lzplt_entry / BFINFDPIC_LZPLT_BLOCK_SIZE 2431 * BFINFDPIC_LZPLT_BLOCK_SIZE + BFINFDPIC_LZPLT_RESOLV_LOC; 2432 if (resolverStub_addr >= bfinfdpic_plt_initial_offset (info)) 2433 resolverStub_addr = bfinfdpic_plt_initial_offset (info) - LZPLT_NORMAL_SIZE - LZPLT_RESOLVER_EXTRA; 2434 2435 if (entry->lzplt_entry == resolverStub_addr) 2436 { 2437 /* This is a lazy PLT entry that includes a resolver call. 2438 P2 = [P3]; 2439 R3 = [P3 + 4]; 2440 JUMP (P2); */ 2441 bfd_put_32 (output_bfd, 2442 0xa05b915a, 2443 lzplt_code); 2444 bfd_put_16 (output_bfd, 0x0052, lzplt_code + 4); 2445 } 2446 else 2447 { 2448 /* JUMP.S resolverStub */ 2449 bfd_put_16 (output_bfd, 2450 0x2000 2451 | (((resolverStub_addr - entry->lzplt_entry) 2452 / 2) & (((bfd_vma)1 << 12) - 1)), 2453 lzplt_code); 2454 } 2455 } 2456 2457 return TRUE; 2458 } 2459 2460 /* Relocate an Blackfin ELF section. 2462 2463 The RELOCATE_SECTION function is called by the new ELF backend linker 2464 to handle the relocations for a section. 2465 2466 The relocs are always passed as Rela structures; if the section 2467 actually uses Rel structures, the r_addend field will always be 2468 zero. 2469 2470 This function is responsible for adjusting the section contents as 2471 necessary, and (if using Rela relocs and generating a relocatable 2472 output file) adjusting the reloc addend as necessary. 2473 2474 This function does not have to worry about setting the reloc 2475 address or the reloc symbol index. 2476 2477 LOCAL_SYMS is a pointer to the swapped in local symbols. 2478 2479 LOCAL_SECTIONS is an array giving the section in the input file 2480 corresponding to the st_shndx field of each local symbol. 2481 2482 The global hash table entry for the global symbols can be found 2483 via elf_sym_hashes (input_bfd). 2484 2485 When generating relocatable output, this function must handle 2486 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 2487 going to be the section symbol corresponding to the output 2488 section, which means that the addend must be adjusted 2489 accordingly. */ 2490 2491 static bfd_boolean 2492 bfinfdpic_relocate_section (bfd * output_bfd, 2493 struct bfd_link_info *info, 2494 bfd * input_bfd, 2495 asection * input_section, 2496 bfd_byte * contents, 2497 Elf_Internal_Rela * relocs, 2498 Elf_Internal_Sym * local_syms, 2499 asection ** local_sections) 2500 { 2501 Elf_Internal_Shdr *symtab_hdr; 2502 struct elf_link_hash_entry **sym_hashes; 2503 Elf_Internal_Rela *rel; 2504 Elf_Internal_Rela *relend; 2505 unsigned isec_segment, got_segment, plt_segment, 2506 check_segment[2]; 2507 int silence_segment_error = !bfd_link_pic (info); 2508 2509 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 2510 sym_hashes = elf_sym_hashes (input_bfd); 2511 relend = relocs + input_section->reloc_count; 2512 2513 isec_segment = _bfinfdpic_osec_to_segment (output_bfd, 2514 input_section->output_section); 2515 if (IS_FDPIC (output_bfd) && bfinfdpic_got_section (info)) 2516 got_segment = _bfinfdpic_osec_to_segment (output_bfd, 2517 bfinfdpic_got_section (info) 2518 ->output_section); 2519 else 2520 got_segment = -1; 2521 if (IS_FDPIC (output_bfd) && elf_hash_table (info)->dynamic_sections_created) 2522 plt_segment = _bfinfdpic_osec_to_segment (output_bfd, 2523 bfinfdpic_plt_section (info) 2524 ->output_section); 2525 else 2526 plt_segment = -1; 2527 2528 for (rel = relocs; rel < relend; rel ++) 2529 { 2530 reloc_howto_type *howto; 2531 unsigned long r_symndx; 2532 Elf_Internal_Sym *sym; 2533 asection *sec; 2534 struct elf_link_hash_entry *h; 2535 bfd_vma relocation; 2536 bfd_reloc_status_type r; 2537 const char * name = NULL; 2538 int r_type; 2539 asection *osec; 2540 struct bfinfdpic_relocs_info *picrel; 2541 bfd_vma orig_addend = rel->r_addend; 2542 2543 r_type = ELF32_R_TYPE (rel->r_info); 2544 2545 if (r_type == R_BFIN_GNU_VTINHERIT 2546 || r_type == R_BFIN_GNU_VTENTRY) 2547 continue; 2548 2549 r_symndx = ELF32_R_SYM (rel->r_info); 2550 howto = bfin_reloc_type_lookup (input_bfd, r_type); 2551 if (howto == NULL) 2552 { 2553 bfd_set_error (bfd_error_bad_value); 2554 return FALSE; 2555 } 2556 2557 h = NULL; 2558 sym = NULL; 2559 sec = NULL; 2560 2561 if (r_symndx < symtab_hdr->sh_info) 2562 { 2563 sym = local_syms + r_symndx; 2564 osec = sec = local_sections [r_symndx]; 2565 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 2566 2567 name = bfd_elf_string_from_elf_section 2568 (input_bfd, symtab_hdr->sh_link, sym->st_name); 2569 name = name == NULL ? bfd_section_name (sec) : name; 2570 } 2571 else 2572 { 2573 bfd_boolean warned, ignored; 2574 bfd_boolean unresolved_reloc; 2575 2576 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 2577 r_symndx, symtab_hdr, sym_hashes, 2578 h, sec, relocation, 2579 unresolved_reloc, warned, ignored); 2580 osec = sec; 2581 } 2582 2583 if (sec != NULL && discarded_section (sec)) 2584 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 2585 rel, 1, relend, howto, 0, contents); 2586 2587 if (bfd_link_relocatable (info)) 2588 continue; 2589 2590 if (h != NULL 2591 && (h->root.type == bfd_link_hash_defined 2592 || h->root.type == bfd_link_hash_defweak) 2593 && !BFINFDPIC_SYM_LOCAL (info, h)) 2594 { 2595 osec = sec = NULL; 2596 relocation = 0; 2597 } 2598 2599 switch (r_type) 2600 { 2601 case R_BFIN_PCREL24: 2602 case R_BFIN_PCREL24_JUMP_L: 2603 case R_BFIN_BYTE4_DATA: 2604 if (! IS_FDPIC (output_bfd)) 2605 goto non_fdpic; 2606 /* Fall through. */ 2607 2608 case R_BFIN_GOT17M4: 2609 case R_BFIN_GOTHI: 2610 case R_BFIN_GOTLO: 2611 case R_BFIN_FUNCDESC_GOT17M4: 2612 case R_BFIN_FUNCDESC_GOTHI: 2613 case R_BFIN_FUNCDESC_GOTLO: 2614 case R_BFIN_GOTOFF17M4: 2615 case R_BFIN_GOTOFFHI: 2616 case R_BFIN_GOTOFFLO: 2617 case R_BFIN_FUNCDESC_GOTOFF17M4: 2618 case R_BFIN_FUNCDESC_GOTOFFHI: 2619 case R_BFIN_FUNCDESC_GOTOFFLO: 2620 case R_BFIN_FUNCDESC: 2621 case R_BFIN_FUNCDESC_VALUE: 2622 if (h != NULL) 2623 picrel = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info 2624 (info), input_bfd, h, 2625 orig_addend, INSERT); 2626 else 2627 /* In order to find the entry we created before, we must 2628 use the original addend, not the one that may have been 2629 modified by _bfd_elf_rela_local_sym(). */ 2630 picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info 2631 (info), input_bfd, r_symndx, 2632 orig_addend, INSERT); 2633 if (! picrel) 2634 return FALSE; 2635 2636 if (!_bfinfdpic_emit_got_relocs_plt_entries (picrel, output_bfd, info, 2637 osec, sym, 2638 rel->r_addend)) 2639 { 2640 _bfd_error_handler 2641 /* xgettext:c-format */ 2642 (_("%pB: relocation at `%pA+%#" PRIx64 "' " 2643 "references symbol `%s' with nonzero addend"), 2644 input_bfd, input_section, (uint64_t) rel->r_offset, name); 2645 return FALSE; 2646 2647 } 2648 2649 break; 2650 2651 default: 2652 non_fdpic: 2653 picrel = NULL; 2654 if (h && ! BFINFDPIC_SYM_LOCAL (info, h) 2655 && _bfd_elf_section_offset (output_bfd, info, input_section, 2656 rel->r_offset) != (bfd_vma) -1) 2657 { 2658 info->callbacks->warning 2659 (info, _("relocation references symbol not defined in the module"), 2660 name, input_bfd, input_section, rel->r_offset); 2661 return FALSE; 2662 } 2663 break; 2664 } 2665 2666 switch (r_type) 2667 { 2668 case R_BFIN_PCREL24: 2669 case R_BFIN_PCREL24_JUMP_L: 2670 check_segment[0] = isec_segment; 2671 if (! IS_FDPIC (output_bfd)) 2672 check_segment[1] = isec_segment; 2673 else if (picrel->plt) 2674 { 2675 relocation = bfinfdpic_plt_section (info)->output_section->vma 2676 + bfinfdpic_plt_section (info)->output_offset 2677 + picrel->plt_entry; 2678 check_segment[1] = plt_segment; 2679 } 2680 /* We don't want to warn on calls to undefined weak symbols, 2681 as calls to them must be protected by non-NULL tests 2682 anyway, and unprotected calls would invoke undefined 2683 behavior. */ 2684 else if (picrel->symndx == -1 2685 && picrel->d.h->root.type == bfd_link_hash_undefweak) 2686 check_segment[1] = check_segment[0]; 2687 else 2688 check_segment[1] = sec 2689 ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section) 2690 : (unsigned)-1; 2691 break; 2692 2693 case R_BFIN_GOT17M4: 2694 case R_BFIN_GOTHI: 2695 case R_BFIN_GOTLO: 2696 relocation = picrel->got_entry; 2697 check_segment[0] = check_segment[1] = got_segment; 2698 break; 2699 2700 case R_BFIN_FUNCDESC_GOT17M4: 2701 case R_BFIN_FUNCDESC_GOTHI: 2702 case R_BFIN_FUNCDESC_GOTLO: 2703 relocation = picrel->fdgot_entry; 2704 check_segment[0] = check_segment[1] = got_segment; 2705 break; 2706 2707 case R_BFIN_GOTOFFHI: 2708 case R_BFIN_GOTOFF17M4: 2709 case R_BFIN_GOTOFFLO: 2710 relocation -= bfinfdpic_got_section (info)->output_section->vma 2711 + bfinfdpic_got_section (info)->output_offset 2712 + bfinfdpic_got_initial_offset (info); 2713 check_segment[0] = got_segment; 2714 check_segment[1] = sec 2715 ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section) 2716 : (unsigned)-1; 2717 break; 2718 2719 case R_BFIN_FUNCDESC_GOTOFF17M4: 2720 case R_BFIN_FUNCDESC_GOTOFFHI: 2721 case R_BFIN_FUNCDESC_GOTOFFLO: 2722 relocation = picrel->fd_entry; 2723 check_segment[0] = check_segment[1] = got_segment; 2724 break; 2725 2726 case R_BFIN_FUNCDESC: 2727 { 2728 int dynindx; 2729 bfd_vma addend = rel->r_addend; 2730 2731 if (! (h && h->root.type == bfd_link_hash_undefweak 2732 && BFINFDPIC_SYM_LOCAL (info, h))) 2733 { 2734 /* If the symbol is dynamic and there may be dynamic 2735 symbol resolution because we are or are linked with a 2736 shared library, emit a FUNCDESC relocation such that 2737 the dynamic linker will allocate the function 2738 descriptor. If the symbol needs a non-local function 2739 descriptor but binds locally (e.g., its visibility is 2740 protected, emit a dynamic relocation decayed to 2741 section+offset. */ 2742 if (h && ! BFINFDPIC_FUNCDESC_LOCAL (info, h) 2743 && BFINFDPIC_SYM_LOCAL (info, h) 2744 && !bfd_link_pde (info)) 2745 { 2746 dynindx = elf_section_data (h->root.u.def.section 2747 ->output_section)->dynindx; 2748 addend += h->root.u.def.section->output_offset 2749 + h->root.u.def.value; 2750 } 2751 else if (h && ! BFINFDPIC_FUNCDESC_LOCAL (info, h)) 2752 { 2753 if (addend) 2754 { 2755 info->callbacks->warning 2756 (info, _("R_BFIN_FUNCDESC references dynamic symbol with nonzero addend"), 2757 name, input_bfd, input_section, rel->r_offset); 2758 return FALSE; 2759 } 2760 dynindx = h->dynindx; 2761 } 2762 else 2763 { 2764 /* Otherwise, we know we have a private function 2765 descriptor, so reference it directly. */ 2766 BFD_ASSERT (picrel->privfd); 2767 r_type = R_BFIN_BYTE4_DATA; 2768 dynindx = elf_section_data (bfinfdpic_got_section (info) 2769 ->output_section)->dynindx; 2770 addend = bfinfdpic_got_section (info)->output_offset 2771 + bfinfdpic_got_initial_offset (info) 2772 + picrel->fd_entry; 2773 } 2774 2775 /* If there is room for dynamic symbol resolution, emit 2776 the dynamic relocation. However, if we're linking an 2777 executable at a fixed location, we won't have emitted a 2778 dynamic symbol entry for the got section, so idx will 2779 be zero, which means we can and should compute the 2780 address of the private descriptor ourselves. */ 2781 if (bfd_link_pde (info) 2782 && (!h || BFINFDPIC_FUNCDESC_LOCAL (info, h))) 2783 { 2784 bfd_vma offset; 2785 2786 addend += bfinfdpic_got_section (info)->output_section->vma; 2787 if ((bfd_section_flags (input_section->output_section) 2788 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) 2789 { 2790 if (_bfinfdpic_osec_readonly_p (output_bfd, 2791 input_section 2792 ->output_section)) 2793 { 2794 info->callbacks->warning 2795 (info, 2796 _("cannot emit fixups in read-only section"), 2797 name, input_bfd, input_section, rel->r_offset); 2798 return FALSE; 2799 } 2800 2801 offset = _bfd_elf_section_offset 2802 (output_bfd, info, 2803 input_section, rel->r_offset); 2804 2805 if (offset != (bfd_vma)-1) 2806 _bfinfdpic_add_rofixup (output_bfd, 2807 bfinfdpic_gotfixup_section 2808 (info), 2809 offset + input_section 2810 ->output_section->vma 2811 + input_section->output_offset, 2812 picrel); 2813 } 2814 } 2815 else if ((bfd_section_flags (input_section->output_section) 2816 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) 2817 { 2818 bfd_vma offset; 2819 2820 if (_bfinfdpic_osec_readonly_p (output_bfd, 2821 input_section 2822 ->output_section)) 2823 { 2824 info->callbacks->warning 2825 (info, 2826 _("cannot emit dynamic relocations in read-only section"), 2827 name, input_bfd, input_section, rel->r_offset); 2828 return FALSE; 2829 } 2830 offset = _bfd_elf_section_offset (output_bfd, info, 2831 input_section, rel->r_offset); 2832 2833 if (offset != (bfd_vma)-1) 2834 _bfinfdpic_add_dyn_reloc (output_bfd, 2835 bfinfdpic_gotrel_section (info), 2836 offset + input_section 2837 ->output_section->vma 2838 + input_section->output_offset, 2839 r_type, 2840 dynindx, addend, picrel); 2841 } 2842 else 2843 addend += bfinfdpic_got_section (info)->output_section->vma; 2844 } 2845 2846 /* We want the addend in-place because dynamic 2847 relocations are REL. Setting relocation to it should 2848 arrange for it to be installed. */ 2849 relocation = addend - rel->r_addend; 2850 } 2851 check_segment[0] = check_segment[1] = got_segment; 2852 break; 2853 2854 case R_BFIN_BYTE4_DATA: 2855 if (! IS_FDPIC (output_bfd)) 2856 { 2857 check_segment[0] = check_segment[1] = -1; 2858 break; 2859 } 2860 /* Fall through. */ 2861 case R_BFIN_FUNCDESC_VALUE: 2862 { 2863 int dynindx; 2864 bfd_vma addend = rel->r_addend; 2865 bfd_vma offset; 2866 offset = _bfd_elf_section_offset (output_bfd, info, 2867 input_section, rel->r_offset); 2868 2869 /* If the symbol is dynamic but binds locally, use 2870 section+offset. */ 2871 if (h && ! BFINFDPIC_SYM_LOCAL (info, h)) 2872 { 2873 if (addend && r_type == R_BFIN_FUNCDESC_VALUE) 2874 { 2875 info->callbacks->warning 2876 (info, _("R_BFIN_FUNCDESC_VALUE references dynamic symbol with nonzero addend"), 2877 name, input_bfd, input_section, rel->r_offset); 2878 return FALSE; 2879 } 2880 dynindx = h->dynindx; 2881 } 2882 else 2883 { 2884 if (h) 2885 addend += h->root.u.def.value; 2886 else 2887 addend += sym->st_value; 2888 if (osec) 2889 addend += osec->output_offset; 2890 if (osec && osec->output_section 2891 && ! bfd_is_abs_section (osec->output_section) 2892 && ! bfd_is_und_section (osec->output_section)) 2893 dynindx = elf_section_data (osec->output_section)->dynindx; 2894 else 2895 dynindx = 0; 2896 } 2897 2898 /* If we're linking an executable at a fixed address, we 2899 can omit the dynamic relocation as long as the symbol 2900 is defined in the current link unit (which is implied 2901 by its output section not being NULL). */ 2902 if (bfd_link_pde (info) 2903 && (!h || BFINFDPIC_SYM_LOCAL (info, h))) 2904 { 2905 if (osec) 2906 addend += osec->output_section->vma; 2907 if (IS_FDPIC (input_bfd) 2908 && (bfd_section_flags (input_section->output_section) 2909 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) 2910 { 2911 if (_bfinfdpic_osec_readonly_p (output_bfd, 2912 input_section 2913 ->output_section)) 2914 { 2915 info->callbacks->warning 2916 (info, 2917 _("cannot emit fixups in read-only section"), 2918 name, input_bfd, input_section, rel->r_offset); 2919 return FALSE; 2920 } 2921 if (!h || h->root.type != bfd_link_hash_undefweak) 2922 { 2923 if (offset != (bfd_vma)-1) 2924 { 2925 _bfinfdpic_add_rofixup (output_bfd, 2926 bfinfdpic_gotfixup_section 2927 (info), 2928 offset + input_section 2929 ->output_section->vma 2930 + input_section->output_offset, 2931 picrel); 2932 2933 if (r_type == R_BFIN_FUNCDESC_VALUE) 2934 _bfinfdpic_add_rofixup 2935 (output_bfd, 2936 bfinfdpic_gotfixup_section (info), 2937 offset + input_section->output_section->vma 2938 + input_section->output_offset + 4, picrel); 2939 } 2940 } 2941 } 2942 } 2943 else 2944 { 2945 if ((bfd_section_flags (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 (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 (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 (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 (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 (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 (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_section_flags (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_section_flags (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. */ 4803 4804 struct bfin_link_hash_entry 4805 { 4806 struct elf_link_hash_entry root; 4807 4808 /* Number of PC relative relocs copied for this symbol. */ 4809 struct bfin_pcrel_relocs_copied *pcrel_relocs_copied; 4810 }; 4811 4812 /* bfin ELF linker hash table. */ 4813 4814 struct bfin_link_hash_table 4815 { 4816 struct elf_link_hash_table root; 4817 4818 /* Small local sym cache. */ 4819 struct sym_cache sym_cache; 4820 }; 4821 4822 #define bfin_hash_entry(ent) ((struct bfin_link_hash_entry *) (ent)) 4823 4824 static struct bfd_hash_entry * 4825 bfin_link_hash_newfunc (struct bfd_hash_entry *entry, 4826 struct bfd_hash_table *table, const char *string) 4827 { 4828 struct bfd_hash_entry *ret = entry; 4829 4830 /* Allocate the structure if it has not already been allocated by a 4831 subclass. */ 4832 if (ret == NULL) 4833 ret = bfd_hash_allocate (table, sizeof (struct bfin_link_hash_entry)); 4834 if (ret == NULL) 4835 return ret; 4836 4837 /* Call the allocation method of the superclass. */ 4838 ret = _bfd_elf_link_hash_newfunc (ret, table, string); 4839 if (ret != NULL) 4840 bfin_hash_entry (ret)->pcrel_relocs_copied = NULL; 4841 4842 return ret; 4843 } 4844 4845 /* Create an bfin ELF linker hash table. */ 4846 4847 static struct bfd_link_hash_table * 4848 bfin_link_hash_table_create (bfd * abfd) 4849 { 4850 struct bfin_link_hash_table *ret; 4851 bfd_size_type amt = sizeof (struct bfin_link_hash_table); 4852 4853 ret = bfd_zmalloc (amt); 4854 if (ret == NULL) 4855 return NULL; 4856 4857 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, 4858 bfin_link_hash_newfunc, 4859 sizeof (struct elf_link_hash_entry), 4860 BFIN_ELF_DATA)) 4861 { 4862 free (ret); 4863 return NULL; 4864 } 4865 4866 ret->sym_cache.abfd = NULL; 4867 4868 return &ret->root.root; 4869 } 4870 4871 /* The size in bytes of an entry in the procedure linkage table. */ 4872 4873 /* Finish up the dynamic sections. */ 4874 4875 static bfd_boolean 4876 bfin_finish_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED, 4877 struct bfd_link_info *info) 4878 { 4879 bfd *dynobj; 4880 asection *sdyn; 4881 4882 dynobj = elf_hash_table (info)->dynobj; 4883 4884 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 4885 4886 if (elf_hash_table (info)->dynamic_sections_created) 4887 { 4888 Elf32_External_Dyn *dyncon, *dynconend; 4889 4890 BFD_ASSERT (sdyn != NULL); 4891 4892 dyncon = (Elf32_External_Dyn *) sdyn->contents; 4893 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 4894 for (; dyncon < dynconend; dyncon++) 4895 { 4896 Elf_Internal_Dyn dyn; 4897 4898 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 4899 4900 } 4901 4902 } 4903 return TRUE; 4904 } 4905 4906 /* Finish up dynamic symbol handling. We set the contents of various 4907 dynamic sections here. */ 4908 4909 static bfd_boolean 4910 bfin_finish_dynamic_symbol (bfd * output_bfd, 4911 struct bfd_link_info *info, 4912 struct elf_link_hash_entry *h, 4913 Elf_Internal_Sym * sym) 4914 { 4915 if (h->got.offset != (bfd_vma) - 1) 4916 { 4917 asection *sgot; 4918 asection *srela; 4919 Elf_Internal_Rela rela; 4920 bfd_byte *loc; 4921 4922 /* This symbol has an entry in the global offset table. 4923 Set it up. */ 4924 4925 sgot = elf_hash_table (info)->sgot; 4926 srela = elf_hash_table (info)->srelgot; 4927 BFD_ASSERT (sgot != NULL && srela != NULL); 4928 4929 rela.r_offset = (sgot->output_section->vma 4930 + sgot->output_offset 4931 + (h->got.offset & ~(bfd_vma) 1)); 4932 4933 /* If this is a -Bsymbolic link, and the symbol is defined 4934 locally, we just want to emit a RELATIVE reloc. Likewise if 4935 the symbol was forced to be local because of a version file. 4936 The entry in the global offset table will already have been 4937 initialized in the relocate_section function. */ 4938 if (bfd_link_pic (info) 4939 && (info->symbolic 4940 || h->dynindx == -1 || h->forced_local) && h->def_regular) 4941 { 4942 _bfd_error_handler (_("*** check this relocation %s"), 4943 __FUNCTION__); 4944 rela.r_info = ELF32_R_INFO (0, R_BFIN_PCREL24); 4945 rela.r_addend = bfd_get_signed_32 (output_bfd, 4946 (sgot->contents 4947 + 4948 (h->got. 4949 offset & ~(bfd_vma) 1))); 4950 } 4951 else 4952 { 4953 bfd_put_32 (output_bfd, (bfd_vma) 0, 4954 sgot->contents + (h->got.offset & ~(bfd_vma) 1)); 4955 rela.r_info = ELF32_R_INFO (h->dynindx, R_BFIN_GOT); 4956 rela.r_addend = 0; 4957 } 4958 4959 loc = srela->contents; 4960 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela); 4961 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 4962 } 4963 4964 if (h->needs_copy) 4965 { 4966 BFD_ASSERT (0); 4967 } 4968 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 4969 if (strcmp (h->root.root.string, "__DYNAMIC") == 0 4970 || h == elf_hash_table (info)->hgot) 4971 sym->st_shndx = SHN_ABS; 4972 4973 return TRUE; 4974 } 4975 4976 /* Adjust a symbol defined by a dynamic object and referenced by a 4977 regular object. The current definition is in some section of the 4978 dynamic object, but we're not including those sections. We have to 4979 change the definition to something the rest of the link can 4980 understand. */ 4981 4982 static bfd_boolean 4983 bfin_adjust_dynamic_symbol (struct bfd_link_info *info, 4984 struct elf_link_hash_entry *h) 4985 { 4986 bfd *dynobj; 4987 asection *s; 4988 unsigned int power_of_two; 4989 4990 dynobj = elf_hash_table (info)->dynobj; 4991 4992 /* Make sure we know what is going on here. */ 4993 BFD_ASSERT (dynobj != NULL 4994 && (h->needs_plt 4995 || h->is_weakalias 4996 || (h->def_dynamic && h->ref_regular && !h->def_regular))); 4997 4998 /* If this is a function, put it in the procedure linkage table. We 4999 will fill in the contents of the procedure linkage table later, 5000 when we know the address of the .got section. */ 5001 if (h->type == STT_FUNC || h->needs_plt) 5002 { 5003 BFD_ASSERT(0); 5004 } 5005 5006 /* If this is a weak symbol, and there is a real definition, the 5007 processor independent code will have arranged for us to see the 5008 real definition first, and we can just use the same value. */ 5009 if (h->is_weakalias) 5010 { 5011 struct elf_link_hash_entry *def = weakdef (h); 5012 BFD_ASSERT (def->root.type == bfd_link_hash_defined); 5013 h->root.u.def.section = def->root.u.def.section; 5014 h->root.u.def.value = def->root.u.def.value; 5015 return TRUE; 5016 } 5017 5018 /* This is a reference to a symbol defined by a dynamic object which 5019 is not a function. */ 5020 5021 /* If we are creating a shared library, we must presume that the 5022 only references to the symbol are via the global offset table. 5023 For such cases we need not do anything here; the relocations will 5024 be handled correctly by relocate_section. */ 5025 if (bfd_link_pic (info)) 5026 return TRUE; 5027 5028 /* We must allocate the symbol in our .dynbss section, which will 5029 become part of the .bss section of the executable. There will be 5030 an entry for this symbol in the .dynsym section. The dynamic 5031 object will contain position independent code, so all references 5032 from the dynamic object to this symbol will go through the global 5033 offset table. The dynamic linker will use the .dynsym entry to 5034 determine the address it must put in the global offset table, so 5035 both the dynamic object and the regular object will refer to the 5036 same memory location for the variable. */ 5037 5038 s = bfd_get_linker_section (dynobj, ".dynbss"); 5039 BFD_ASSERT (s != NULL); 5040 5041 #if 0 /* Bfin does not currently have a COPY reloc. */ 5042 /* We must generate a R_BFIN_COPY reloc to tell the dynamic linker to 5043 copy the initial value out of the dynamic object and into the 5044 runtime process image. We need to remember the offset into the 5045 .rela.bss section we are going to use. */ 5046 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 5047 { 5048 asection *srel; 5049 5050 srel = bfd_get_linker_section (dynobj, ".rela.bss"); 5051 BFD_ASSERT (srel != NULL); 5052 srel->size += sizeof (Elf32_External_Rela); 5053 h->needs_copy = 1; 5054 } 5055 #else 5056 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 5057 { 5058 _bfd_error_handler (_("the bfin target does not currently support the generation of copy relocations")); 5059 return FALSE; 5060 } 5061 #endif 5062 /* We need to figure out the alignment required for this symbol. I 5063 have no idea how ELF linkers handle this. */ 5064 power_of_two = bfd_log2 (h->size); 5065 if (power_of_two > 3) 5066 power_of_two = 3; 5067 5068 /* Apply the required alignment. */ 5069 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two)); 5070 if (power_of_two > bfd_section_alignment (s)) 5071 { 5072 if (!bfd_set_section_alignment (s, power_of_two)) 5073 return FALSE; 5074 } 5075 5076 /* Define the symbol as being at this point in the section. */ 5077 h->root.u.def.section = s; 5078 h->root.u.def.value = s->size; 5079 5080 /* Increment the section size to make room for the symbol. */ 5081 s->size += h->size; 5082 5083 return TRUE; 5084 } 5085 5086 /* The bfin linker needs to keep track of the number of relocs that it 5087 decides to copy in check_relocs for each symbol. This is so that it 5088 can discard PC relative relocs if it doesn't need them when linking 5089 with -Bsymbolic. We store the information in a field extending the 5090 regular ELF linker hash table. */ 5091 5092 /* This structure keeps track of the number of PC relative relocs we have 5093 copied for a given symbol. */ 5094 5095 struct bfin_pcrel_relocs_copied 5096 { 5097 /* Next section. */ 5098 struct bfin_pcrel_relocs_copied *next; 5099 /* A section in dynobj. */ 5100 asection *section; 5101 /* Number of relocs copied in this section. */ 5102 bfd_size_type count; 5103 }; 5104 5105 /* This function is called via elf_link_hash_traverse if we are 5106 creating a shared object. In the -Bsymbolic case it discards the 5107 space allocated to copy PC relative relocs against symbols which 5108 are defined in regular objects. For the normal shared case, it 5109 discards space for pc-relative relocs that have become local due to 5110 symbol visibility changes. We allocated space for them in the 5111 check_relocs routine, but we won't fill them in in the 5112 relocate_section routine. 5113 5114 We also check whether any of the remaining relocations apply 5115 against a readonly section, and set the DF_TEXTREL flag in this 5116 case. */ 5117 5118 static bfd_boolean 5119 bfin_discard_copies (struct elf_link_hash_entry *h, void * inf) 5120 { 5121 struct bfd_link_info *info = (struct bfd_link_info *) inf; 5122 struct bfin_pcrel_relocs_copied *s; 5123 5124 if (!h->def_regular || (!info->symbolic && !h->forced_local)) 5125 { 5126 if ((info->flags & DF_TEXTREL) == 0) 5127 { 5128 /* Look for relocations against read-only sections. */ 5129 for (s = bfin_hash_entry (h)->pcrel_relocs_copied; 5130 s != NULL; s = s->next) 5131 if ((s->section->flags & SEC_READONLY) != 0) 5132 { 5133 info->flags |= DF_TEXTREL; 5134 break; 5135 } 5136 } 5137 5138 return TRUE; 5139 } 5140 5141 for (s = bfin_hash_entry (h)->pcrel_relocs_copied; 5142 s != NULL; s = s->next) 5143 s->section->size -= s->count * sizeof (Elf32_External_Rela); 5144 5145 return TRUE; 5146 } 5147 5148 static bfd_boolean 5149 bfin_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED, 5150 struct bfd_link_info *info) 5151 { 5152 bfd *dynobj; 5153 asection *s; 5154 bfd_boolean relocs; 5155 5156 dynobj = elf_hash_table (info)->dynobj; 5157 BFD_ASSERT (dynobj != NULL); 5158 5159 if (elf_hash_table (info)->dynamic_sections_created) 5160 { 5161 /* Set the contents of the .interp section to the interpreter. */ 5162 if (bfd_link_executable (info) && !info->nointerp) 5163 { 5164 s = bfd_get_linker_section (dynobj, ".interp"); 5165 BFD_ASSERT (s != NULL); 5166 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 5167 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 5168 } 5169 } 5170 else 5171 { 5172 /* We may have created entries in the .rela.got section. 5173 However, if we are not creating the dynamic sections, we will 5174 not actually use these entries. Reset the size of .rela.got, 5175 which will cause it to get stripped from the output file 5176 below. */ 5177 s = elf_hash_table (info)->srelgot; 5178 if (s != NULL) 5179 s->size = 0; 5180 } 5181 5182 /* If this is a -Bsymbolic shared link, then we need to discard all 5183 PC relative relocs against symbols defined in a regular object. 5184 For the normal shared case we discard the PC relative relocs 5185 against symbols that have become local due to visibility changes. 5186 We allocated space for them in the check_relocs routine, but we 5187 will not fill them in in the relocate_section routine. */ 5188 if (bfd_link_pic (info)) 5189 elf_link_hash_traverse (elf_hash_table (info), 5190 bfin_discard_copies, info); 5191 5192 /* The check_relocs and adjust_dynamic_symbol entry points have 5193 determined the sizes of the various dynamic sections. Allocate 5194 memory for them. */ 5195 relocs = FALSE; 5196 for (s = dynobj->sections; s != NULL; s = s->next) 5197 { 5198 const char *name; 5199 bfd_boolean strip; 5200 5201 if ((s->flags & SEC_LINKER_CREATED) == 0) 5202 continue; 5203 5204 /* It's OK to base decisions on the section name, because none 5205 of the dynobj section names depend upon the input files. */ 5206 name = bfd_section_name (s); 5207 5208 strip = FALSE; 5209 5210 if (CONST_STRNEQ (name, ".rela")) 5211 { 5212 if (s->size == 0) 5213 { 5214 /* If we don't need this section, strip it from the 5215 output file. This is mostly to handle .rela.bss and 5216 .rela.plt. We must create both sections in 5217 create_dynamic_sections, because they must be created 5218 before the linker maps input sections to output 5219 sections. The linker does that before 5220 adjust_dynamic_symbol is called, and it is that 5221 function which decides whether anything needs to go 5222 into these sections. */ 5223 strip = TRUE; 5224 } 5225 else 5226 { 5227 relocs = TRUE; 5228 5229 /* We use the reloc_count field as a counter if we need 5230 to copy relocs into the output file. */ 5231 s->reloc_count = 0; 5232 } 5233 } 5234 else if (! CONST_STRNEQ (name, ".got")) 5235 { 5236 /* It's not one of our sections, so don't allocate space. */ 5237 continue; 5238 } 5239 5240 if (strip) 5241 { 5242 s->flags |= SEC_EXCLUDE; 5243 continue; 5244 } 5245 5246 /* Allocate memory for the section contents. */ 5247 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc. 5248 Unused entries should be reclaimed before the section's contents 5249 are written out, but at the moment this does not happen. Thus in 5250 order to prevent writing out garbage, we initialise the section's 5251 contents to zero. */ 5252 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 5253 if (s->contents == NULL && s->size != 0) 5254 return FALSE; 5255 } 5256 5257 if (elf_hash_table (info)->dynamic_sections_created) 5258 { 5259 /* Add some entries to the .dynamic section. We fill in the 5260 values later, in bfin_finish_dynamic_sections, but we 5261 must add the entries now so that we get the correct size for 5262 the .dynamic section. The DT_DEBUG entry is filled in by the 5263 dynamic linker and used by the debugger. */ 5264 #define add_dynamic_entry(TAG, VAL) \ 5265 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 5266 5267 if (!bfd_link_pic (info)) 5268 { 5269 if (!add_dynamic_entry (DT_DEBUG, 0)) 5270 return FALSE; 5271 } 5272 5273 5274 if (relocs) 5275 { 5276 if (!add_dynamic_entry (DT_RELA, 0) 5277 || !add_dynamic_entry (DT_RELASZ, 0) 5278 || !add_dynamic_entry (DT_RELAENT, 5279 sizeof (Elf32_External_Rela))) 5280 return FALSE; 5281 } 5282 5283 if ((info->flags & DF_TEXTREL) != 0) 5284 { 5285 if (!add_dynamic_entry (DT_TEXTREL, 0)) 5286 return FALSE; 5287 } 5288 } 5289 #undef add_dynamic_entry 5290 5291 return TRUE; 5292 } 5293 5294 /* Given a .data section and a .emreloc in-memory section, store 5296 relocation information into the .emreloc section which can be 5297 used at runtime to relocate the section. This is called by the 5298 linker when the --embedded-relocs switch is used. This is called 5299 after the add_symbols entry point has been called for all the 5300 objects, and before the final_link entry point is called. */ 5301 5302 bfd_boolean 5303 bfd_bfin_elf32_create_embedded_relocs (bfd *abfd, 5304 struct bfd_link_info *info, 5305 asection *datasec, 5306 asection *relsec, 5307 char **errmsg) 5308 { 5309 Elf_Internal_Shdr *symtab_hdr; 5310 Elf_Internal_Sym *isymbuf = NULL; 5311 Elf_Internal_Rela *internal_relocs = NULL; 5312 Elf_Internal_Rela *irel, *irelend; 5313 bfd_byte *p; 5314 bfd_size_type amt; 5315 5316 BFD_ASSERT (! bfd_link_relocatable (info)); 5317 5318 *errmsg = NULL; 5319 5320 if (datasec->reloc_count == 0) 5321 return TRUE; 5322 5323 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 5324 5325 /* Get a copy of the native relocations. */ 5326 internal_relocs = (_bfd_elf_link_read_relocs 5327 (abfd, datasec, NULL, (Elf_Internal_Rela *) NULL, 5328 info->keep_memory)); 5329 if (internal_relocs == NULL) 5330 goto error_return; 5331 5332 amt = (bfd_size_type) datasec->reloc_count * 12; 5333 relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt); 5334 if (relsec->contents == NULL) 5335 goto error_return; 5336 5337 p = relsec->contents; 5338 5339 irelend = internal_relocs + datasec->reloc_count; 5340 for (irel = internal_relocs; irel < irelend; irel++, p += 12) 5341 { 5342 asection *targetsec; 5343 5344 /* We are going to write a four byte longword into the runtime 5345 reloc section. The longword will be the address in the data 5346 section which must be relocated. It is followed by the name 5347 of the target section NUL-padded or truncated to 8 5348 characters. */ 5349 5350 /* We can only relocate absolute longword relocs at run time. */ 5351 if (ELF32_R_TYPE (irel->r_info) != (int) R_BFIN_BYTE4_DATA) 5352 { 5353 *errmsg = _("unsupported relocation type"); 5354 bfd_set_error (bfd_error_bad_value); 5355 goto error_return; 5356 } 5357 5358 /* Get the target section referred to by the reloc. */ 5359 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 5360 { 5361 /* A local symbol. */ 5362 Elf_Internal_Sym *isym; 5363 5364 /* Read this BFD's local symbols if we haven't done so already. */ 5365 if (isymbuf == NULL) 5366 { 5367 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 5368 if (isymbuf == NULL) 5369 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 5370 symtab_hdr->sh_info, 0, 5371 NULL, NULL, NULL); 5372 if (isymbuf == NULL) 5373 goto error_return; 5374 } 5375 5376 isym = isymbuf + ELF32_R_SYM (irel->r_info); 5377 targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx); 5378 } 5379 else 5380 { 5381 unsigned long indx; 5382 struct elf_link_hash_entry *h; 5383 5384 /* An external symbol. */ 5385 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 5386 h = elf_sym_hashes (abfd)[indx]; 5387 BFD_ASSERT (h != NULL); 5388 if (h->root.type == bfd_link_hash_defined 5389 || h->root.type == bfd_link_hash_defweak) 5390 targetsec = h->root.u.def.section; 5391 else 5392 targetsec = NULL; 5393 } 5394 5395 bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p); 5396 memset (p + 4, 0, 8); 5397 if (targetsec != NULL) 5398 strncpy ((char *) p + 4, targetsec->output_section->name, 8); 5399 } 5400 5401 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf) 5402 free (isymbuf); 5403 if (internal_relocs != NULL 5404 && elf_section_data (datasec)->relocs != internal_relocs) 5405 free (internal_relocs); 5406 return TRUE; 5407 5408 error_return: 5409 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf) 5410 free (isymbuf); 5411 if (internal_relocs != NULL 5412 && elf_section_data (datasec)->relocs != internal_relocs) 5413 free (internal_relocs); 5414 return FALSE; 5415 } 5416 5417 struct bfd_elf_special_section const elf32_bfin_special_sections[] = 5418 { 5419 { ".l1.text", 8, -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR }, 5420 { ".l1.data", 8, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 5421 { NULL, 0, 0, 0, 0 } 5422 }; 5423 5424 5425 #define TARGET_LITTLE_SYM bfin_elf32_vec 5427 #define TARGET_LITTLE_NAME "elf32-bfin" 5428 #define ELF_ARCH bfd_arch_bfin 5429 #define ELF_TARGET_ID BFIN_ELF_DATA 5430 #define ELF_MACHINE_CODE EM_BLACKFIN 5431 #define ELF_MAXPAGESIZE 0x1000 5432 #define elf_symbol_leading_char '_' 5433 5434 #define bfd_elf32_bfd_reloc_type_lookup bfin_bfd_reloc_type_lookup 5435 #define bfd_elf32_bfd_reloc_name_lookup \ 5436 bfin_bfd_reloc_name_lookup 5437 #define elf_info_to_howto bfin_info_to_howto 5438 #define elf_info_to_howto_rel NULL 5439 #define elf_backend_object_p elf32_bfin_object_p 5440 5441 #define bfd_elf32_bfd_is_local_label_name \ 5442 bfin_is_local_label_name 5443 #define bfin_hash_table(p) \ 5444 ((struct bfin_link_hash_table *) (p)->hash) 5445 5446 5447 5448 #define elf_backend_create_dynamic_sections \ 5449 _bfd_elf_create_dynamic_sections 5450 #define bfd_elf32_bfd_link_hash_table_create \ 5451 bfin_link_hash_table_create 5452 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link 5453 5454 #define elf_backend_check_relocs bfin_check_relocs 5455 #define elf_backend_adjust_dynamic_symbol \ 5456 bfin_adjust_dynamic_symbol 5457 #define elf_backend_size_dynamic_sections \ 5458 bfin_size_dynamic_sections 5459 #define elf_backend_relocate_section bfin_relocate_section 5460 #define elf_backend_finish_dynamic_symbol \ 5461 bfin_finish_dynamic_symbol 5462 #define elf_backend_finish_dynamic_sections \ 5463 bfin_finish_dynamic_sections 5464 #define elf_backend_gc_mark_hook bfin_gc_mark_hook 5465 #define bfd_elf32_bfd_merge_private_bfd_data \ 5466 elf32_bfin_merge_private_bfd_data 5467 #define bfd_elf32_bfd_set_private_flags \ 5468 elf32_bfin_set_private_flags 5469 #define bfd_elf32_bfd_print_private_bfd_data \ 5470 elf32_bfin_print_private_bfd_data 5471 #define elf_backend_final_write_processing \ 5472 elf32_bfin_final_write_processing 5473 #define elf_backend_reloc_type_class elf32_bfin_reloc_type_class 5474 #define elf_backend_stack_align 8 5475 #define elf_backend_can_gc_sections 1 5476 #define elf_backend_special_sections elf32_bfin_special_sections 5477 #define elf_backend_can_refcount 1 5478 #define elf_backend_want_got_plt 0 5479 #define elf_backend_plt_readonly 1 5480 #define elf_backend_want_plt_sym 0 5481 #define elf_backend_got_header_size 12 5482 #define elf_backend_rela_normal 1 5483 5484 #include "elf32-target.h" 5485 5486 #undef TARGET_LITTLE_SYM 5487 #define TARGET_LITTLE_SYM bfin_elf32_fdpic_vec 5488 #undef TARGET_LITTLE_NAME 5489 #define TARGET_LITTLE_NAME "elf32-bfinfdpic" 5490 #undef elf32_bed 5491 #define elf32_bed elf32_bfinfdpic_bed 5492 5493 #undef elf_backend_got_header_size 5494 #define elf_backend_got_header_size 0 5495 5496 #undef elf_backend_relocate_section 5497 #define elf_backend_relocate_section bfinfdpic_relocate_section 5498 #undef elf_backend_check_relocs 5499 #define elf_backend_check_relocs bfinfdpic_check_relocs 5500 5501 #undef bfd_elf32_bfd_link_hash_table_create 5502 #define bfd_elf32_bfd_link_hash_table_create \ 5503 bfinfdpic_elf_link_hash_table_create 5504 #undef elf_backend_always_size_sections 5505 #define elf_backend_always_size_sections \ 5506 elf32_bfinfdpic_always_size_sections 5507 5508 #undef elf_backend_create_dynamic_sections 5509 #define elf_backend_create_dynamic_sections \ 5510 elf32_bfinfdpic_create_dynamic_sections 5511 #undef elf_backend_adjust_dynamic_symbol 5512 #define elf_backend_adjust_dynamic_symbol \ 5513 elf32_bfinfdpic_adjust_dynamic_symbol 5514 #undef elf_backend_size_dynamic_sections 5515 #define elf_backend_size_dynamic_sections \ 5516 elf32_bfinfdpic_size_dynamic_sections 5517 #undef elf_backend_finish_dynamic_symbol 5518 #define elf_backend_finish_dynamic_symbol \ 5519 elf32_bfinfdpic_finish_dynamic_symbol 5520 #undef elf_backend_finish_dynamic_sections 5521 #define elf_backend_finish_dynamic_sections \ 5522 elf32_bfinfdpic_finish_dynamic_sections 5523 5524 #undef elf_backend_discard_info 5525 #define elf_backend_discard_info \ 5526 bfinfdpic_elf_discard_info 5527 #undef elf_backend_can_make_relative_eh_frame 5528 #define elf_backend_can_make_relative_eh_frame \ 5529 bfinfdpic_elf_use_relative_eh_frame 5530 #undef elf_backend_can_make_lsda_relative_eh_frame 5531 #define elf_backend_can_make_lsda_relative_eh_frame \ 5532 bfinfdpic_elf_use_relative_eh_frame 5533 #undef elf_backend_encode_eh_address 5534 #define elf_backend_encode_eh_address \ 5535 bfinfdpic_elf_encode_eh_address 5536 5537 #undef elf_backend_may_use_rel_p 5538 #define elf_backend_may_use_rel_p 1 5539 #undef elf_backend_may_use_rela_p 5540 #define elf_backend_may_use_rela_p 1 5541 /* We use REL for dynamic relocations only. */ 5542 #undef elf_backend_default_use_rela_p 5543 #define elf_backend_default_use_rela_p 1 5544 5545 #undef elf_backend_omit_section_dynsym 5546 #define elf_backend_omit_section_dynsym _bfinfdpic_link_omit_section_dynsym 5547 5548 #include "elf32-target.h" 5549
Indexes created Sun Mar 01 05:31:48 UTC 2026