1 /* Lattice Mico32-specific support for 32-bit ELF 2 Copyright (C) 2008-2017 Free Software Foundation, Inc. 3 Contributed by Jon Beniston <jon@beniston.com> 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22 #include "sysdep.h" 23 #include "bfd.h" 24 #include "libbfd.h" 25 #include "elf-bfd.h" 26 #include "elf/lm32.h" 27 28 #define DEFAULT_STACK_SIZE 0x20000 29 30 #define PLT_ENTRY_SIZE 20 31 32 #define PLT0_ENTRY_WORD0 0 33 #define PLT0_ENTRY_WORD1 0 34 #define PLT0_ENTRY_WORD2 0 35 #define PLT0_ENTRY_WORD3 0 36 #define PLT0_ENTRY_WORD4 0 37 38 #define PLT0_PIC_ENTRY_WORD0 0 39 #define PLT0_PIC_ENTRY_WORD1 0 40 #define PLT0_PIC_ENTRY_WORD2 0 41 #define PLT0_PIC_ENTRY_WORD3 0 42 #define PLT0_PIC_ENTRY_WORD4 0 43 44 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1" 45 46 extern const bfd_target lm32_elf32_fdpic_vec; 47 48 #define IS_FDPIC(bfd) ((bfd)->xvec == &lm32_elf32_fdpic_vec) 49 50 static bfd_reloc_status_type lm32_elf_gprel_reloc 51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 52 53 /* The linker needs to keep track of the number of relocs that it 54 decides to copy as dynamic relocs in check_relocs for each symbol. 55 This is so that it can later discard them if they are found to be 56 unnecessary. We store the information in a field extending the 57 regular ELF linker hash table. */ 58 59 struct elf_lm32_dyn_relocs 60 { 61 struct elf_lm32_dyn_relocs *next; 62 63 /* The input section of the reloc. */ 64 asection *sec; 65 66 /* Total number of relocs copied for the input section. */ 67 bfd_size_type count; 68 69 /* Number of pc-relative relocs copied for the input section. */ 70 bfd_size_type pc_count; 71 }; 72 73 /* lm32 ELF linker hash entry. */ 74 75 struct elf_lm32_link_hash_entry 76 { 77 struct elf_link_hash_entry root; 78 79 /* Track dynamic relocs copied for this symbol. */ 80 struct elf_lm32_dyn_relocs *dyn_relocs; 81 }; 82 83 /* lm32 ELF linker hash table. */ 84 85 struct elf_lm32_link_hash_table 86 { 87 struct elf_link_hash_table root; 88 89 /* Short-cuts to get to dynamic linker sections. */ 90 asection *sfixup32; 91 asection *sdynbss; 92 asection *srelbss; 93 94 int relocs32; 95 }; 96 97 /* Get the lm32 ELF linker hash table from a link_info structure. */ 98 99 #define lm32_elf_hash_table(p) \ 100 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ 101 == LM32_ELF_DATA ? ((struct elf_lm32_link_hash_table *) ((p)->hash)) : NULL) 102 103 #define lm32fdpic_got_section(info) \ 104 (lm32_elf_hash_table (info)->root.sgot) 105 #define lm32fdpic_gotrel_section(info) \ 106 (lm32_elf_hash_table (info)->root.srelgot) 107 #define lm32fdpic_fixup32_section(info) \ 108 (lm32_elf_hash_table (info)->sfixup32) 109 110 struct weak_symbol_list 111 { 112 const char *name; 113 struct weak_symbol_list *next; 114 }; 115 116 /* Create an entry in an lm32 ELF linker hash table. */ 117 118 static struct bfd_hash_entry * 119 lm32_elf_link_hash_newfunc (struct bfd_hash_entry *entry, 120 struct bfd_hash_table *table, 121 const char *string) 122 { 123 struct elf_lm32_link_hash_entry *ret = 124 (struct elf_lm32_link_hash_entry *) entry; 125 126 /* Allocate the structure if it has not already been allocated by a 127 subclass. */ 128 if (ret == NULL) 129 ret = bfd_hash_allocate (table, 130 sizeof (struct elf_lm32_link_hash_entry)); 131 if (ret == NULL) 132 return NULL; 133 134 /* Call the allocation method of the superclass. */ 135 ret = ((struct elf_lm32_link_hash_entry *) 136 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, 137 table, string)); 138 if (ret != NULL) 139 { 140 struct elf_lm32_link_hash_entry *eh; 141 142 eh = (struct elf_lm32_link_hash_entry *) ret; 143 eh->dyn_relocs = NULL; 144 } 145 146 return (struct bfd_hash_entry *) ret; 147 } 148 149 /* Create an lm32 ELF linker hash table. */ 150 151 static struct bfd_link_hash_table * 152 lm32_elf_link_hash_table_create (bfd *abfd) 153 { 154 struct elf_lm32_link_hash_table *ret; 155 bfd_size_type amt = sizeof (struct elf_lm32_link_hash_table); 156 157 ret = bfd_zmalloc (amt); 158 if (ret == NULL) 159 return NULL; 160 161 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, 162 lm32_elf_link_hash_newfunc, 163 sizeof (struct elf_lm32_link_hash_entry), 164 LM32_ELF_DATA)) 165 { 166 free (ret); 167 return NULL; 168 } 169 170 return &ret->root.root; 171 } 172 173 /* Add a fixup to the ROFIXUP section. */ 174 175 static bfd_vma 176 _lm32fdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma relocation) 177 { 178 bfd_vma fixup_offset; 179 180 if (rofixup->flags & SEC_EXCLUDE) 181 return -1; 182 183 fixup_offset = rofixup->reloc_count * 4; 184 if (rofixup->contents) 185 { 186 BFD_ASSERT (fixup_offset < rofixup->size); 187 if (fixup_offset < rofixup->size) 188 bfd_put_32 (output_bfd, relocation, rofixup->contents + fixup_offset); 189 } 190 rofixup->reloc_count++; 191 192 return fixup_offset; 193 } 194 195 /* Create .rofixup sections in DYNOBJ, and set up 196 shortcuts to them in our hash table. */ 197 198 static bfd_boolean 199 create_rofixup_section (bfd *dynobj, struct bfd_link_info *info) 200 { 201 struct elf_lm32_link_hash_table *htab; 202 htab = lm32_elf_hash_table (info); 203 204 if (htab == NULL) 205 return FALSE; 206 207 /* Fixup section for R_LM32_32 relocs. */ 208 lm32fdpic_fixup32_section (info) 209 = bfd_make_section_anyway_with_flags (dynobj, 210 ".rofixup", 211 (SEC_ALLOC 212 | SEC_LOAD 213 | SEC_HAS_CONTENTS 214 | SEC_IN_MEMORY 215 | SEC_LINKER_CREATED 216 | SEC_READONLY)); 217 if (lm32fdpic_fixup32_section (info) == NULL 218 || ! bfd_set_section_alignment (dynobj, 219 lm32fdpic_fixup32_section (info), 2)) 220 return FALSE; 221 222 return TRUE; 223 } 224 225 static reloc_howto_type lm32_elf_howto_table [] = 226 { 227 /* This reloc does nothing. */ 228 HOWTO (R_LM32_NONE, /* type */ 229 0, /* rightshift */ 230 3, /* size (0 = byte, 1 = short, 2 = long) */ 231 0, /* bitsize */ 232 FALSE, /* pc_relative */ 233 0, /* bitpos */ 234 complain_overflow_dont, /* complain_on_overflow */ 235 bfd_elf_generic_reloc, /* special_function */ 236 "R_LM32_NONE", /* name */ 237 FALSE, /* partial_inplace */ 238 0, /* src_mask */ 239 0, /* dst_mask */ 240 FALSE), /* pcrel_offset */ 241 242 /* An 8 bit absolute relocation. */ 243 HOWTO (R_LM32_8, /* type */ 244 0, /* rightshift */ 245 0, /* size (0 = byte, 1 = short, 2 = long) */ 246 8, /* bitsize */ 247 FALSE, /* pc_relative */ 248 0, /* bitpos */ 249 complain_overflow_bitfield,/* complain_on_overflow */ 250 bfd_elf_generic_reloc, /* special_function */ 251 "R_LM32_8", /* name */ 252 FALSE, /* partial_inplace */ 253 0, /* src_mask */ 254 0xff, /* dst_mask */ 255 FALSE), /* pcrel_offset */ 256 257 /* A 16 bit absolute relocation. */ 258 HOWTO (R_LM32_16, /* type */ 259 0, /* rightshift */ 260 1, /* size (0 = byte, 1 = short, 2 = long) */ 261 16, /* bitsize */ 262 FALSE, /* pc_relative */ 263 0, /* bitpos */ 264 complain_overflow_bitfield,/* complain_on_overflow */ 265 bfd_elf_generic_reloc, /* special_function */ 266 "R_LM32_16", /* name */ 267 FALSE, /* partial_inplace */ 268 0, /* src_mask */ 269 0xffff, /* dst_mask */ 270 FALSE), /* pcrel_offset */ 271 272 /* A 32 bit absolute relocation. */ 273 HOWTO (R_LM32_32, /* type */ 274 0, /* rightshift */ 275 2, /* size (0 = byte, 1 = short, 2 = long) */ 276 32, /* bitsize */ 277 FALSE, /* pc_relative */ 278 0, /* bitpos */ 279 complain_overflow_bitfield,/* complain_on_overflow */ 280 bfd_elf_generic_reloc, /* special_function */ 281 "R_LM32_32", /* name */ 282 FALSE, /* partial_inplace */ 283 0, /* src_mask */ 284 0xffffffff, /* dst_mask */ 285 FALSE), /* pcrel_offset */ 286 287 HOWTO (R_LM32_HI16, /* type */ 288 16, /* rightshift */ 289 2, /* size (0 = byte, 1 = short, 2 = long) */ 290 16, /* bitsize */ 291 FALSE, /* pc_relative */ 292 0, /* bitpos */ 293 complain_overflow_bitfield,/* complain_on_overflow */ 294 bfd_elf_generic_reloc, /* special_function */ 295 "R_LM32_HI16", /* name */ 296 FALSE, /* partial_inplace */ 297 0, /* src_mask */ 298 0xffff, /* dst_mask */ 299 FALSE), /* pcrel_offset */ 300 301 HOWTO (R_LM32_LO16, /* type */ 302 0, /* rightshift */ 303 2, /* size (0 = byte, 1 = short, 2 = long) */ 304 16, /* bitsize */ 305 FALSE, /* pc_relative */ 306 0, /* bitpos */ 307 complain_overflow_dont, /* complain_on_overflow */ 308 bfd_elf_generic_reloc, /* special_function */ 309 "R_LM32_LO16", /* name */ 310 FALSE, /* partial_inplace */ 311 0, /* src_mask */ 312 0xffff, /* dst_mask */ 313 FALSE), /* pcrel_offset */ 314 315 HOWTO (R_LM32_GPREL16, /* type */ 316 0, /* rightshift */ 317 2, /* size (0 = byte, 1 = short, 2 = long) */ 318 16, /* bitsize */ 319 FALSE, /* pc_relative */ 320 0, /* bitpos */ 321 complain_overflow_dont, /* complain_on_overflow */ 322 lm32_elf_gprel_reloc, /* special_function */ 323 "R_LM32_GPREL16", /* name */ 324 FALSE, /* partial_inplace */ 325 0, /* src_mask */ 326 0xffff, /* dst_mask */ 327 FALSE), /* pcrel_offset */ 328 329 HOWTO (R_LM32_CALL, /* type */ 330 2, /* rightshift */ 331 2, /* size (0 = byte, 1 = short, 2 = long) */ 332 26, /* bitsize */ 333 TRUE, /* pc_relative */ 334 0, /* bitpos */ 335 complain_overflow_signed, /* complain_on_overflow */ 336 bfd_elf_generic_reloc, /* special_function */ 337 "R_LM32_CALL", /* name */ 338 FALSE, /* partial_inplace */ 339 0, /* src_mask */ 340 0x3ffffff, /* dst_mask */ 341 TRUE), /* pcrel_offset */ 342 343 HOWTO (R_LM32_BRANCH, /* type */ 344 2, /* rightshift */ 345 2, /* size (0 = byte, 1 = short, 2 = long) */ 346 16, /* bitsize */ 347 TRUE, /* pc_relative */ 348 0, /* bitpos */ 349 complain_overflow_signed, /* complain_on_overflow */ 350 bfd_elf_generic_reloc, /* special_function */ 351 "R_LM32_BRANCH", /* name */ 352 FALSE, /* partial_inplace */ 353 0, /* src_mask */ 354 0xffff, /* dst_mask */ 355 TRUE), /* pcrel_offset */ 356 357 /* GNU extension to record C++ vtable hierarchy. */ 358 HOWTO (R_LM32_GNU_VTINHERIT, /* type */ 359 0, /* rightshift */ 360 2, /* size (0 = byte, 1 = short, 2 = long) */ 361 0, /* bitsize */ 362 FALSE, /* pc_relative */ 363 0, /* bitpos */ 364 complain_overflow_dont, /* complain_on_overflow */ 365 NULL, /* special_function */ 366 "R_LM32_GNU_VTINHERIT", /* name */ 367 FALSE, /* partial_inplace */ 368 0, /* src_mask */ 369 0, /* dst_mask */ 370 FALSE), /* pcrel_offset */ 371 372 /* GNU extension to record C++ vtable member usage. */ 373 HOWTO (R_LM32_GNU_VTENTRY, /* type */ 374 0, /* rightshift */ 375 2, /* size (0 = byte, 1 = short, 2 = long) */ 376 0, /* bitsize */ 377 FALSE, /* pc_relative */ 378 0, /* bitpos */ 379 complain_overflow_dont, /* complain_on_overflow */ 380 _bfd_elf_rel_vtable_reloc_fn,/* special_function */ 381 "R_LM32_GNU_VTENTRY", /* name */ 382 FALSE, /* partial_inplace */ 383 0, /* src_mask */ 384 0, /* dst_mask */ 385 FALSE), /* pcrel_offset */ 386 387 HOWTO (R_LM32_16_GOT, /* type */ 388 0, /* rightshift */ 389 2, /* size (0 = byte, 1 = short, 2 = long) */ 390 16, /* bitsize */ 391 FALSE, /* pc_relative */ 392 0, /* bitpos */ 393 complain_overflow_signed, /* complain_on_overflow */ 394 bfd_elf_generic_reloc, /* special_function */ 395 "R_LM32_16_GOT", /* name */ 396 FALSE, /* partial_inplace */ 397 0, /* src_mask */ 398 0xffff, /* dst_mask */ 399 FALSE), /* pcrel_offset */ 400 401 HOWTO (R_LM32_GOTOFF_HI16, /* type */ 402 16, /* rightshift */ 403 2, /* size (0 = byte, 1 = short, 2 = long) */ 404 16, /* bitsize */ 405 FALSE, /* pc_relative */ 406 0, /* bitpos */ 407 complain_overflow_dont, /* complain_on_overflow */ 408 bfd_elf_generic_reloc, /* special_function */ 409 "R_LM32_GOTOFF_HI16", /* name */ 410 FALSE, /* partial_inplace */ 411 0xffff, /* src_mask */ 412 0xffff, /* dst_mask */ 413 FALSE), /* pcrel_offset */ 414 415 HOWTO (R_LM32_GOTOFF_LO16, /* type */ 416 0, /* rightshift */ 417 2, /* size (0 = byte, 1 = short, 2 = long) */ 418 16, /* bitsize */ 419 FALSE, /* pc_relative */ 420 0, /* bitpos */ 421 complain_overflow_dont, /* complain_on_overflow */ 422 bfd_elf_generic_reloc, /* special_function */ 423 "R_LM32_GOTOFF_LO16", /* name */ 424 FALSE, /* partial_inplace */ 425 0xffff, /* src_mask */ 426 0xffff, /* dst_mask */ 427 FALSE), /* pcrel_offset */ 428 429 HOWTO (R_LM32_COPY, /* type */ 430 0, /* rightshift */ 431 2, /* size (0 = byte, 1 = short, 2 = long) */ 432 32, /* bitsize */ 433 FALSE, /* pc_relative */ 434 0, /* bitpos */ 435 complain_overflow_bitfield, /* complain_on_overflow */ 436 bfd_elf_generic_reloc, /* special_function */ 437 "R_LM32_COPY", /* name */ 438 FALSE, /* partial_inplace */ 439 0xffffffff, /* src_mask */ 440 0xffffffff, /* dst_mask */ 441 FALSE), /* pcrel_offset */ 442 443 HOWTO (R_LM32_GLOB_DAT, /* type */ 444 0, /* rightshift */ 445 2, /* size (0 = byte, 1 = short, 2 = long) */ 446 32, /* bitsize */ 447 FALSE, /* pc_relative */ 448 0, /* bitpos */ 449 complain_overflow_bitfield, /* complain_on_overflow */ 450 bfd_elf_generic_reloc, /* special_function */ 451 "R_LM32_GLOB_DAT", /* name */ 452 FALSE, /* partial_inplace */ 453 0xffffffff, /* src_mask */ 454 0xffffffff, /* dst_mask */ 455 FALSE), /* pcrel_offset */ 456 457 HOWTO (R_LM32_JMP_SLOT, /* type */ 458 0, /* rightshift */ 459 2, /* size (0 = byte, 1 = short, 2 = long) */ 460 32, /* bitsize */ 461 FALSE, /* pc_relative */ 462 0, /* bitpos */ 463 complain_overflow_bitfield, /* complain_on_overflow */ 464 bfd_elf_generic_reloc, /* special_function */ 465 "R_LM32_JMP_SLOT", /* name */ 466 FALSE, /* partial_inplace */ 467 0xffffffff, /* src_mask */ 468 0xffffffff, /* dst_mask */ 469 FALSE), /* pcrel_offset */ 470 471 HOWTO (R_LM32_RELATIVE, /* type */ 472 0, /* rightshift */ 473 2, /* size (0 = byte, 1 = short, 2 = long) */ 474 32, /* bitsize */ 475 FALSE, /* pc_relative */ 476 0, /* bitpos */ 477 complain_overflow_bitfield, /* complain_on_overflow */ 478 bfd_elf_generic_reloc, /* special_function */ 479 "R_LM32_RELATIVE", /* name */ 480 FALSE, /* partial_inplace */ 481 0xffffffff, /* src_mask */ 482 0xffffffff, /* dst_mask */ 483 FALSE), /* pcrel_offset */ 484 485 }; 486 487 /* Map BFD reloc types to lm32 ELF reloc types. */ 488 489 struct lm32_reloc_map 490 { 491 bfd_reloc_code_real_type bfd_reloc_val; 492 unsigned char elf_reloc_val; 493 }; 494 495 static const struct lm32_reloc_map lm32_reloc_map[] = 496 { 497 { BFD_RELOC_NONE, R_LM32_NONE }, 498 { BFD_RELOC_8, R_LM32_8 }, 499 { BFD_RELOC_16, R_LM32_16 }, 500 { BFD_RELOC_32, R_LM32_32 }, 501 { BFD_RELOC_HI16, R_LM32_HI16 }, 502 { BFD_RELOC_LO16, R_LM32_LO16 }, 503 { BFD_RELOC_GPREL16, R_LM32_GPREL16 }, 504 { BFD_RELOC_LM32_CALL, R_LM32_CALL }, 505 { BFD_RELOC_LM32_BRANCH, R_LM32_BRANCH }, 506 { BFD_RELOC_VTABLE_INHERIT, R_LM32_GNU_VTINHERIT }, 507 { BFD_RELOC_VTABLE_ENTRY, R_LM32_GNU_VTENTRY }, 508 { BFD_RELOC_LM32_16_GOT, R_LM32_16_GOT }, 509 { BFD_RELOC_LM32_GOTOFF_HI16, R_LM32_GOTOFF_HI16 }, 510 { BFD_RELOC_LM32_GOTOFF_LO16, R_LM32_GOTOFF_LO16 }, 511 { BFD_RELOC_LM32_COPY, R_LM32_COPY }, 512 { BFD_RELOC_LM32_GLOB_DAT, R_LM32_GLOB_DAT }, 513 { BFD_RELOC_LM32_JMP_SLOT, R_LM32_JMP_SLOT }, 514 { BFD_RELOC_LM32_RELATIVE, R_LM32_RELATIVE }, 515 }; 516 517 static reloc_howto_type * 518 lm32_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 519 bfd_reloc_code_real_type code) 520 { 521 unsigned int i; 522 523 for (i = 0; i < sizeof (lm32_reloc_map) / sizeof (lm32_reloc_map[0]); i++) 524 if (lm32_reloc_map[i].bfd_reloc_val == code) 525 return &lm32_elf_howto_table[lm32_reloc_map[i].elf_reloc_val]; 526 return NULL; 527 } 528 529 static reloc_howto_type * 530 lm32_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 531 const char *r_name) 532 { 533 unsigned int i; 534 535 for (i = 0; 536 i < sizeof (lm32_elf_howto_table) / sizeof (lm32_elf_howto_table[0]); 537 i++) 538 if (lm32_elf_howto_table[i].name != NULL 539 && strcasecmp (lm32_elf_howto_table[i].name, r_name) == 0) 540 return &lm32_elf_howto_table[i]; 541 542 return NULL; 543 } 544 545 546 /* Set the howto pointer for an Lattice Mico32 ELF reloc. */ 547 548 static void 549 lm32_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED, 550 arelent *cache_ptr, 551 Elf_Internal_Rela *dst) 552 { 553 unsigned int r_type; 554 555 r_type = ELF32_R_TYPE (dst->r_info); 556 if (r_type >= (unsigned int) R_LM32_max) 557 { 558 /* xgettext:c-format */ 559 _bfd_error_handler (_("%B: invalid LM32 reloc number: %d"), abfd, r_type); 560 r_type = 0; 561 } 562 cache_ptr->howto = &lm32_elf_howto_table[r_type]; 563 } 564 565 /* Set the right machine number for an Lattice Mico32 ELF file. */ 566 567 static bfd_boolean 568 lm32_elf_object_p (bfd *abfd) 569 { 570 return bfd_default_set_arch_mach (abfd, bfd_arch_lm32, bfd_mach_lm32); 571 } 572 573 /* Set machine type flags just before file is written out. */ 574 575 static void 576 lm32_elf_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED) 577 { 578 elf_elfheader (abfd)->e_machine = EM_LATTICEMICO32; 579 elf_elfheader (abfd)->e_flags &=~ EF_LM32_MACH; 580 switch (bfd_get_mach (abfd)) 581 { 582 case bfd_mach_lm32: 583 elf_elfheader (abfd)->e_flags |= E_LM32_MACH; 584 break; 585 default: 586 abort (); 587 } 588 } 589 590 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a 591 dangerous relocation. */ 592 593 static bfd_boolean 594 lm32_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp) 595 { 596 unsigned int count; 597 asymbol **sym; 598 unsigned int i; 599 600 /* If we've already figured out what GP will be, just return it. */ 601 *pgp = _bfd_get_gp_value (output_bfd); 602 if (*pgp) 603 return TRUE; 604 605 count = bfd_get_symcount (output_bfd); 606 sym = bfd_get_outsymbols (output_bfd); 607 608 /* The linker script will have created a symbol named `_gp' with the 609 appropriate value. */ 610 if (sym == NULL) 611 i = count; 612 else 613 { 614 for (i = 0; i < count; i++, sym++) 615 { 616 const char *name; 617 618 name = bfd_asymbol_name (*sym); 619 if (*name == '_' && strcmp (name, "_gp") == 0) 620 { 621 *pgp = bfd_asymbol_value (*sym); 622 _bfd_set_gp_value (output_bfd, *pgp); 623 break; 624 } 625 } 626 } 627 628 if (i >= count) 629 { 630 /* Only get the error once. */ 631 *pgp = 4; 632 _bfd_set_gp_value (output_bfd, *pgp); 633 return FALSE; 634 } 635 636 return TRUE; 637 } 638 639 /* We have to figure out the gp value, so that we can adjust the 640 symbol value correctly. We look up the symbol _gp in the output 641 BFD. If we can't find it, we're stuck. We cache it in the ELF 642 target data. We don't need to adjust the symbol value for an 643 external symbol if we are producing relocatable output. */ 644 645 static bfd_reloc_status_type 646 lm32_elf_final_gp (bfd *output_bfd, asymbol *symbol, bfd_boolean relocatable, 647 char **error_message, bfd_vma *pgp) 648 { 649 if (bfd_is_und_section (symbol->section) && !relocatable) 650 { 651 *pgp = 0; 652 return bfd_reloc_undefined; 653 } 654 655 *pgp = _bfd_get_gp_value (output_bfd); 656 if (*pgp == 0 && (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0)) 657 { 658 if (relocatable) 659 { 660 /* Make up a value. */ 661 *pgp = symbol->section->output_section->vma + 0x4000; 662 _bfd_set_gp_value (output_bfd, *pgp); 663 } 664 else if (!lm32_elf_assign_gp (output_bfd, pgp)) 665 { 666 *error_message = 667 (char *) 668 _("global pointer relative relocation when _gp not defined"); 669 return bfd_reloc_dangerous; 670 } 671 } 672 673 return bfd_reloc_ok; 674 } 675 676 static bfd_reloc_status_type 677 lm32_elf_do_gprel_relocate (bfd *abfd, 678 reloc_howto_type *howto, 679 asection *input_section ATTRIBUTE_UNUSED, 680 bfd_byte *data, 681 bfd_vma offset, 682 bfd_vma symbol_value, 683 bfd_vma addend) 684 { 685 return _bfd_final_link_relocate (howto, abfd, input_section, 686 data, offset, symbol_value, addend); 687 } 688 689 static bfd_reloc_status_type 690 lm32_elf_gprel_reloc (bfd *abfd, 691 arelent *reloc_entry, 692 asymbol *symbol, 693 void *data, 694 asection *input_section, 695 bfd *output_bfd, 696 char **msg) 697 { 698 bfd_vma relocation; 699 bfd_vma gp; 700 bfd_reloc_status_type r; 701 702 if (output_bfd != (bfd *) NULL 703 && (symbol->flags & BSF_SECTION_SYM) == 0 704 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0)) 705 { 706 reloc_entry->address += input_section->output_offset; 707 return bfd_reloc_ok; 708 } 709 710 if (output_bfd != NULL) 711 return bfd_reloc_ok; 712 713 relocation = symbol->value 714 + symbol->section->output_section->vma + symbol->section->output_offset; 715 716 if ((r = 717 lm32_elf_final_gp (abfd, symbol, FALSE, msg, &gp)) == bfd_reloc_ok) 718 { 719 relocation = relocation + reloc_entry->addend - gp; 720 reloc_entry->addend = 0; 721 if ((signed) relocation < -32768 || (signed) relocation > 32767) 722 { 723 *msg = _("global pointer relative address out of range"); 724 r = bfd_reloc_outofrange; 725 } 726 else 727 { 728 r = lm32_elf_do_gprel_relocate (abfd, reloc_entry->howto, 729 input_section, 730 data, reloc_entry->address, 731 relocation, reloc_entry->addend); 732 } 733 } 734 735 return r; 736 } 737 738 /* Find the segment number in which OSEC, and output section, is 739 located. */ 740 741 static unsigned 742 _lm32fdpic_osec_to_segment (bfd *output_bfd, asection *osec) 743 { 744 struct elf_segment_map *m; 745 Elf_Internal_Phdr *p; 746 747 /* Find the segment that contains the output_section. */ 748 for (m = elf_seg_map (output_bfd), p = elf_tdata (output_bfd)->phdr; 749 m != NULL; 750 m = m->next, p++) 751 { 752 int i; 753 754 for (i = m->count - 1; i >= 0; i--) 755 if (m->sections[i] == osec) 756 break; 757 758 if (i >= 0) 759 break; 760 } 761 762 return p - elf_tdata (output_bfd)->phdr; 763 } 764 765 /* Determine if an output section is read-only. */ 766 767 inline static bfd_boolean 768 _lm32fdpic_osec_readonly_p (bfd *output_bfd, asection *osec) 769 { 770 unsigned seg = _lm32fdpic_osec_to_segment (output_bfd, osec); 771 772 return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W); 773 } 774 775 /* Relocate a section */ 776 777 static bfd_boolean 778 lm32_elf_relocate_section (bfd *output_bfd, 779 struct bfd_link_info *info, 780 bfd *input_bfd, 781 asection *input_section, 782 bfd_byte *contents, 783 Elf_Internal_Rela *relocs, 784 Elf_Internal_Sym *local_syms, 785 asection **local_sections) 786 { 787 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 788 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd); 789 Elf_Internal_Rela *rel, *relend; 790 struct elf_lm32_link_hash_table *htab = lm32_elf_hash_table (info); 791 bfd_vma *local_got_offsets; 792 asection *sgot; 793 794 if (htab == NULL) 795 return FALSE; 796 797 local_got_offsets = elf_local_got_offsets (input_bfd); 798 799 sgot = htab->root.sgot; 800 801 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 802 sym_hashes = elf_sym_hashes (input_bfd); 803 804 rel = relocs; 805 relend = relocs + input_section->reloc_count; 806 for (; rel < relend; rel++) 807 { 808 reloc_howto_type *howto; 809 unsigned int r_type; 810 unsigned long r_symndx; 811 Elf_Internal_Sym *sym; 812 asection *sec; 813 struct elf_link_hash_entry *h; 814 bfd_vma relocation; 815 bfd_vma gp; 816 bfd_reloc_status_type r; 817 const char *name = NULL; 818 819 r_symndx = ELF32_R_SYM (rel->r_info); 820 r_type = ELF32_R_TYPE (rel->r_info); 821 822 if (r_type == R_LM32_GNU_VTENTRY 823 || r_type == R_LM32_GNU_VTINHERIT ) 824 continue; 825 826 h = NULL; 827 sym = NULL; 828 sec = NULL; 829 830 howto = lm32_elf_howto_table + r_type; 831 832 if (r_symndx < symtab_hdr->sh_info) 833 { 834 /* It's a local symbol. */ 835 sym = local_syms + r_symndx; 836 sec = local_sections[r_symndx]; 837 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 838 name = bfd_elf_string_from_elf_section 839 (input_bfd, symtab_hdr->sh_link, sym->st_name); 840 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name; 841 } 842 else 843 { 844 /* It's a global symbol. */ 845 bfd_boolean unresolved_reloc; 846 bfd_boolean warned, ignored; 847 848 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 849 r_symndx, symtab_hdr, sym_hashes, 850 h, sec, relocation, 851 unresolved_reloc, warned, ignored); 852 name = h->root.root.string; 853 } 854 855 if (sec != NULL && discarded_section (sec)) 856 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 857 rel, 1, relend, howto, 0, contents); 858 859 if (bfd_link_relocatable (info)) 860 { 861 /* This is a relocatable link. We don't have to change 862 anything, unless the reloc is against a section symbol, 863 in which case we have to adjust according to where the 864 section symbol winds up in the output section. */ 865 if (sym == NULL || ELF_ST_TYPE (sym->st_info) != STT_SECTION) 866 continue; 867 868 /* If partial_inplace, we need to store any additional addend 869 back in the section. */ 870 if (! howto->partial_inplace) 871 continue; 872 873 /* Shouldn't reach here. */ 874 abort (); 875 r = bfd_reloc_ok; 876 } 877 else 878 { 879 switch (howto->type) 880 { 881 case R_LM32_GPREL16: 882 if (!lm32_elf_assign_gp (output_bfd, &gp)) 883 r = bfd_reloc_dangerous; 884 else 885 { 886 relocation = relocation + rel->r_addend - gp; 887 rel->r_addend = 0; 888 if ((signed)relocation < -32768 || (signed)relocation > 32767) 889 r = bfd_reloc_outofrange; 890 else 891 { 892 r = _bfd_final_link_relocate (howto, input_bfd, 893 input_section, contents, 894 rel->r_offset, relocation, 895 rel->r_addend); 896 } 897 } 898 break; 899 case R_LM32_16_GOT: 900 /* Relocation is to the entry for this symbol in the global 901 offset table. */ 902 BFD_ASSERT (sgot != NULL); 903 if (h != NULL) 904 { 905 bfd_boolean dyn; 906 bfd_vma off; 907 908 off = h->got.offset; 909 BFD_ASSERT (off != (bfd_vma) -1); 910 911 dyn = htab->root.dynamic_sections_created; 912 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 913 bfd_link_pic (info), 914 h) 915 || (bfd_link_pic (info) 916 && (info->symbolic 917 || h->dynindx == -1 918 || h->forced_local) 919 && h->def_regular)) 920 { 921 /* This is actually a static link, or it is a 922 -Bsymbolic link and the symbol is defined 923 locally, or the symbol was forced to be local 924 because of a version file. We must initialize 925 this entry in the global offset table. Since the 926 offset must always be a multiple of 4, we use the 927 least significant bit to record whether we have 928 initialized it already. 929 930 When doing a dynamic link, we create a .rela.got 931 relocation entry to initialize the value. This 932 is done in the finish_dynamic_symbol routine. */ 933 if ((off & 1) != 0) 934 off &= ~1; 935 else 936 { 937 /* Write entry in GOT */ 938 bfd_put_32 (output_bfd, relocation, 939 sgot->contents + off); 940 /* Create entry in .rofixup pointing to GOT entry. */ 941 if (IS_FDPIC (output_bfd) && h->root.type != bfd_link_hash_undefweak) 942 { 943 _lm32fdpic_add_rofixup (output_bfd, 944 lm32fdpic_fixup32_section 945 (info), 946 sgot->output_section->vma 947 + sgot->output_offset 948 + off); 949 } 950 /* Mark GOT entry as having been written. */ 951 h->got.offset |= 1; 952 } 953 } 954 955 relocation = sgot->output_offset + off; 956 } 957 else 958 { 959 bfd_vma off; 960 bfd_byte *loc; 961 962 BFD_ASSERT (local_got_offsets != NULL 963 && local_got_offsets[r_symndx] != (bfd_vma) -1); 964 965 /* Get offset into GOT table. */ 966 off = local_got_offsets[r_symndx]; 967 968 /* The offset must always be a multiple of 4. We use 969 the least significant bit to record whether we have 970 already processed this entry. */ 971 if ((off & 1) != 0) 972 off &= ~1; 973 else 974 { 975 /* Write entry in GOT. */ 976 bfd_put_32 (output_bfd, relocation, sgot->contents + off); 977 /* Create entry in .rofixup pointing to GOT entry. */ 978 if (IS_FDPIC (output_bfd)) 979 { 980 _lm32fdpic_add_rofixup (output_bfd, 981 lm32fdpic_fixup32_section 982 (info), 983 sgot->output_section->vma 984 + sgot->output_offset 985 + off); 986 } 987 988 if (bfd_link_pic (info)) 989 { 990 asection *srelgot; 991 Elf_Internal_Rela outrel; 992 993 /* We need to generate a R_LM32_RELATIVE reloc 994 for the dynamic linker. */ 995 srelgot = htab->root.srelgot; 996 BFD_ASSERT (srelgot != NULL); 997 998 outrel.r_offset = (sgot->output_section->vma 999 + sgot->output_offset 1000 + off); 1001 outrel.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE); 1002 outrel.r_addend = relocation; 1003 loc = srelgot->contents; 1004 loc += srelgot->reloc_count * sizeof (Elf32_External_Rela); 1005 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc); 1006 ++srelgot->reloc_count; 1007 } 1008 1009 local_got_offsets[r_symndx] |= 1; 1010 } 1011 1012 1013 relocation = sgot->output_offset + off; 1014 } 1015 1016 /* Addend should be zero. */ 1017 if (rel->r_addend != 0) 1018 _bfd_error_handler (_("internal error: addend should be zero for R_LM32_16_GOT")); 1019 1020 r = _bfd_final_link_relocate (howto, 1021 input_bfd, 1022 input_section, 1023 contents, 1024 rel->r_offset, 1025 relocation, 1026 rel->r_addend); 1027 break; 1028 1029 case R_LM32_GOTOFF_LO16: 1030 case R_LM32_GOTOFF_HI16: 1031 /* Relocation is offset from GOT. */ 1032 BFD_ASSERT (sgot != NULL); 1033 relocation -= sgot->output_section->vma; 1034 /* Account for sign-extension. */ 1035 if ((r_type == R_LM32_GOTOFF_HI16) 1036 && ((relocation + rel->r_addend) & 0x8000)) 1037 rel->r_addend += 0x10000; 1038 r = _bfd_final_link_relocate (howto, 1039 input_bfd, 1040 input_section, 1041 contents, 1042 rel->r_offset, 1043 relocation, 1044 rel->r_addend); 1045 break; 1046 1047 case R_LM32_32: 1048 if (IS_FDPIC (output_bfd)) 1049 { 1050 if ((!h) || (h && h->root.type != bfd_link_hash_undefweak)) 1051 { 1052 /* Only create .rofixup entries for relocs in loadable sections. */ 1053 if ((bfd_get_section_flags (output_bfd, input_section->output_section) 1054 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) 1055 1056 { 1057 /* Check address to be modified is writable. */ 1058 if (_lm32fdpic_osec_readonly_p (output_bfd, 1059 input_section 1060 ->output_section)) 1061 { 1062 info->callbacks->warning 1063 (info, 1064 _("cannot emit dynamic relocations in read-only section"), 1065 name, input_bfd, input_section, rel->r_offset); 1066 return FALSE; 1067 } 1068 /* Create entry in .rofixup section. */ 1069 _lm32fdpic_add_rofixup (output_bfd, 1070 lm32fdpic_fixup32_section (info), 1071 input_section->output_section->vma 1072 + input_section->output_offset 1073 + rel->r_offset); 1074 } 1075 } 1076 } 1077 /* Fall through. */ 1078 1079 default: 1080 r = _bfd_final_link_relocate (howto, 1081 input_bfd, 1082 input_section, 1083 contents, 1084 rel->r_offset, 1085 relocation, 1086 rel->r_addend); 1087 break; 1088 } 1089 } 1090 1091 if (r != bfd_reloc_ok) 1092 { 1093 const char *msg = NULL; 1094 arelent bfd_reloc; 1095 1096 lm32_info_to_howto_rela (input_bfd, &bfd_reloc, rel); 1097 howto = bfd_reloc.howto; 1098 1099 if (h != NULL) 1100 name = h->root.root.string; 1101 else 1102 { 1103 name = (bfd_elf_string_from_elf_section 1104 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 1105 if (name == NULL || *name == '\0') 1106 name = bfd_section_name (input_bfd, sec); 1107 } 1108 1109 switch (r) 1110 { 1111 case bfd_reloc_overflow: 1112 if ((h != NULL) 1113 && (h->root.type == bfd_link_hash_undefweak)) 1114 break; 1115 (*info->callbacks->reloc_overflow) 1116 (info, (h ? &h->root : NULL), name, howto->name, 1117 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 1118 break; 1119 1120 case bfd_reloc_undefined: 1121 (*info->callbacks->undefined_symbol) 1122 (info, name, input_bfd, input_section, rel->r_offset, TRUE); 1123 break; 1124 1125 case bfd_reloc_outofrange: 1126 msg = _("internal error: out of range error"); 1127 goto common_error; 1128 1129 case bfd_reloc_notsupported: 1130 msg = _("internal error: unsupported relocation error"); 1131 goto common_error; 1132 1133 case bfd_reloc_dangerous: 1134 msg = _("internal error: dangerous error"); 1135 goto common_error; 1136 1137 default: 1138 msg = _("internal error: unknown error"); 1139 /* fall through */ 1140 1141 common_error: 1142 (*info->callbacks->warning) (info, msg, name, input_bfd, 1143 input_section, rel->r_offset); 1144 break; 1145 } 1146 } 1147 } 1148 1149 return TRUE; 1150 } 1151 1152 static asection * 1153 lm32_elf_gc_mark_hook (asection *sec, 1154 struct bfd_link_info *info, 1155 Elf_Internal_Rela *rel, 1156 struct elf_link_hash_entry *h, 1157 Elf_Internal_Sym *sym) 1158 { 1159 if (h != NULL) 1160 switch (ELF32_R_TYPE (rel->r_info)) 1161 { 1162 case R_LM32_GNU_VTINHERIT: 1163 case R_LM32_GNU_VTENTRY: 1164 return NULL; 1165 } 1166 1167 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 1168 } 1169 1170 static bfd_boolean 1171 lm32_elf_gc_sweep_hook (bfd *abfd, 1172 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1173 asection *sec, 1174 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED) 1175 { 1176 /* Update the got entry reference counts for the section being removed. */ 1177 Elf_Internal_Shdr *symtab_hdr; 1178 struct elf_link_hash_entry **sym_hashes; 1179 bfd_signed_vma *local_got_refcounts; 1180 const Elf_Internal_Rela *rel, *relend; 1181 1182 elf_section_data (sec)->local_dynrel = NULL; 1183 1184 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1185 sym_hashes = elf_sym_hashes (abfd); 1186 local_got_refcounts = elf_local_got_refcounts (abfd); 1187 1188 relend = relocs + sec->reloc_count; 1189 for (rel = relocs; rel < relend; rel++) 1190 { 1191 unsigned long r_symndx; 1192 struct elf_link_hash_entry *h = NULL; 1193 1194 r_symndx = ELF32_R_SYM (rel->r_info); 1195 if (r_symndx >= symtab_hdr->sh_info) 1196 { 1197 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1198 while (h->root.type == bfd_link_hash_indirect 1199 || h->root.type == bfd_link_hash_warning) 1200 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1201 } 1202 1203 switch (ELF32_R_TYPE (rel->r_info)) 1204 { 1205 case R_LM32_16_GOT: 1206 if (h != NULL) 1207 { 1208 if (h->got.refcount > 0) 1209 h->got.refcount--; 1210 } 1211 else 1212 { 1213 if (local_got_refcounts && local_got_refcounts[r_symndx] > 0) 1214 local_got_refcounts[r_symndx]--; 1215 } 1216 break; 1217 1218 default: 1219 break; 1220 } 1221 } 1222 return TRUE; 1223 } 1224 1225 /* Look through the relocs for a section during the first phase. */ 1226 1227 static bfd_boolean 1228 lm32_elf_check_relocs (bfd *abfd, 1229 struct bfd_link_info *info, 1230 asection *sec, 1231 const Elf_Internal_Rela *relocs) 1232 { 1233 Elf_Internal_Shdr *symtab_hdr; 1234 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end; 1235 const Elf_Internal_Rela *rel; 1236 const Elf_Internal_Rela *rel_end; 1237 struct elf_lm32_link_hash_table *htab; 1238 bfd *dynobj; 1239 1240 if (bfd_link_relocatable (info)) 1241 return TRUE; 1242 1243 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1244 sym_hashes = elf_sym_hashes (abfd); 1245 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym); 1246 if (!elf_bad_symtab (abfd)) 1247 sym_hashes_end -= symtab_hdr->sh_info; 1248 1249 htab = lm32_elf_hash_table (info); 1250 if (htab == NULL) 1251 return FALSE; 1252 1253 dynobj = htab->root.dynobj; 1254 1255 rel_end = relocs + sec->reloc_count; 1256 for (rel = relocs; rel < rel_end; rel++) 1257 { 1258 int r_type; 1259 struct elf_link_hash_entry *h; 1260 unsigned long r_symndx; 1261 1262 r_symndx = ELF32_R_SYM (rel->r_info); 1263 r_type = ELF32_R_TYPE (rel->r_info); 1264 if (r_symndx < symtab_hdr->sh_info) 1265 h = NULL; 1266 else 1267 { 1268 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1269 while (h->root.type == bfd_link_hash_indirect 1270 || h->root.type == bfd_link_hash_warning) 1271 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1272 1273 /* PR15323, ref flags aren't set for references in the same 1274 object. */ 1275 h->root.non_ir_ref = 1; 1276 } 1277 1278 /* Some relocs require a global offset table. */ 1279 if (htab->root.sgot == NULL) 1280 { 1281 switch (r_type) 1282 { 1283 case R_LM32_16_GOT: 1284 case R_LM32_GOTOFF_HI16: 1285 case R_LM32_GOTOFF_LO16: 1286 if (dynobj == NULL) 1287 htab->root.dynobj = dynobj = abfd; 1288 if (!_bfd_elf_create_got_section (dynobj, info)) 1289 return FALSE; 1290 break; 1291 } 1292 } 1293 1294 /* Some relocs require a rofixup table. */ 1295 if (IS_FDPIC (abfd)) 1296 { 1297 switch (r_type) 1298 { 1299 case R_LM32_32: 1300 /* FDPIC requires a GOT if there is a .rofixup section 1301 (Normal ELF doesn't). */ 1302 if (dynobj == NULL) 1303 htab->root.dynobj = dynobj = abfd; 1304 if (!_bfd_elf_create_got_section (dynobj, info)) 1305 return FALSE; 1306 /* Create .rofixup section */ 1307 if (htab->sfixup32 == NULL) 1308 { 1309 if (! create_rofixup_section (dynobj, info)) 1310 return FALSE; 1311 } 1312 break; 1313 case R_LM32_16_GOT: 1314 case R_LM32_GOTOFF_HI16: 1315 case R_LM32_GOTOFF_LO16: 1316 /* Create .rofixup section. */ 1317 if (htab->sfixup32 == NULL) 1318 { 1319 if (dynobj == NULL) 1320 htab->root.dynobj = dynobj = abfd; 1321 if (! create_rofixup_section (dynobj, info)) 1322 return FALSE; 1323 } 1324 break; 1325 } 1326 } 1327 1328 switch (r_type) 1329 { 1330 case R_LM32_16_GOT: 1331 if (h != NULL) 1332 h->got.refcount += 1; 1333 else 1334 { 1335 bfd_signed_vma *local_got_refcounts; 1336 1337 /* This is a global offset table entry for a local symbol. */ 1338 local_got_refcounts = elf_local_got_refcounts (abfd); 1339 if (local_got_refcounts == NULL) 1340 { 1341 bfd_size_type size; 1342 1343 size = symtab_hdr->sh_info; 1344 size *= sizeof (bfd_signed_vma); 1345 local_got_refcounts = bfd_zalloc (abfd, size); 1346 if (local_got_refcounts == NULL) 1347 return FALSE; 1348 elf_local_got_refcounts (abfd) = local_got_refcounts; 1349 } 1350 local_got_refcounts[r_symndx] += 1; 1351 } 1352 break; 1353 1354 /* This relocation describes the C++ object vtable hierarchy. 1355 Reconstruct it for later use during GC. */ 1356 case R_LM32_GNU_VTINHERIT: 1357 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 1358 return FALSE; 1359 break; 1360 1361 /* This relocation describes which C++ vtable entries are actually 1362 used. Record for later use during GC. */ 1363 case R_LM32_GNU_VTENTRY: 1364 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 1365 return FALSE; 1366 break; 1367 1368 } 1369 } 1370 1371 return TRUE; 1372 } 1373 1374 /* Finish up the dynamic sections. */ 1375 1376 static bfd_boolean 1377 lm32_elf_finish_dynamic_sections (bfd *output_bfd, 1378 struct bfd_link_info *info) 1379 { 1380 struct elf_lm32_link_hash_table *htab; 1381 bfd *dynobj; 1382 asection *sdyn; 1383 asection *sgot; 1384 1385 htab = lm32_elf_hash_table (info); 1386 if (htab == NULL) 1387 return FALSE; 1388 1389 dynobj = htab->root.dynobj; 1390 1391 sgot = htab->root.sgotplt; 1392 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 1393 1394 if (htab->root.dynamic_sections_created) 1395 { 1396 asection *splt; 1397 Elf32_External_Dyn *dyncon, *dynconend; 1398 1399 BFD_ASSERT (sgot != NULL && sdyn != NULL); 1400 1401 dyncon = (Elf32_External_Dyn *) sdyn->contents; 1402 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 1403 1404 for (; dyncon < dynconend; dyncon++) 1405 { 1406 Elf_Internal_Dyn dyn; 1407 asection *s; 1408 1409 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 1410 1411 switch (dyn.d_tag) 1412 { 1413 default: 1414 break; 1415 1416 case DT_PLTGOT: 1417 s = htab->root.sgotplt; 1418 goto get_vma; 1419 case DT_JMPREL: 1420 s = htab->root.srelplt; 1421 get_vma: 1422 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 1423 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 1424 break; 1425 1426 case DT_PLTRELSZ: 1427 s = htab->root.srelplt; 1428 dyn.d_un.d_val = s->size; 1429 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 1430 break; 1431 } 1432 } 1433 1434 /* Fill in the first entry in the procedure linkage table. */ 1435 splt = htab->root.splt; 1436 if (splt && splt->size > 0) 1437 { 1438 if (bfd_link_pic (info)) 1439 { 1440 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents); 1441 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4); 1442 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8); 1443 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12); 1444 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16); 1445 } 1446 else 1447 { 1448 unsigned long addr; 1449 /* addr = .got + 4 */ 1450 addr = sgot->output_section->vma + sgot->output_offset + 4; 1451 bfd_put_32 (output_bfd, 1452 PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff), 1453 splt->contents); 1454 bfd_put_32 (output_bfd, 1455 PLT0_ENTRY_WORD1 | (addr & 0xffff), 1456 splt->contents + 4); 1457 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8); 1458 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12); 1459 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16); 1460 } 1461 1462 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 1463 PLT_ENTRY_SIZE; 1464 } 1465 } 1466 1467 /* Fill in the first three entries in the global offset table. */ 1468 if (sgot && sgot->size > 0) 1469 { 1470 if (sdyn == NULL) 1471 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); 1472 else 1473 bfd_put_32 (output_bfd, 1474 sdyn->output_section->vma + sdyn->output_offset, 1475 sgot->contents); 1476 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4); 1477 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8); 1478 1479 /* FIXME: This can be null if create_dynamic_sections wasn't called. */ 1480 if (elf_section_data (sgot->output_section) != NULL) 1481 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 1482 } 1483 1484 if (lm32fdpic_fixup32_section (info)) 1485 { 1486 struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot; 1487 bfd_vma got_value = hgot->root.u.def.value 1488 + hgot->root.u.def.section->output_section->vma 1489 + hgot->root.u.def.section->output_offset; 1490 struct bfd_link_hash_entry *hend; 1491 1492 /* Last entry is pointer to GOT. */ 1493 _lm32fdpic_add_rofixup (output_bfd, lm32fdpic_fixup32_section (info), got_value); 1494 1495 /* Check we wrote enough entries. */ 1496 if (lm32fdpic_fixup32_section (info)->size 1497 != (lm32fdpic_fixup32_section (info)->reloc_count * 4)) 1498 { 1499 _bfd_error_handler 1500 ("LINKER BUG: .rofixup section size mismatch: size/4 %d != relocs %d", 1501 lm32fdpic_fixup32_section (info)->size/4, 1502 lm32fdpic_fixup32_section (info)->reloc_count); 1503 return FALSE; 1504 } 1505 1506 hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__", 1507 FALSE, FALSE, TRUE); 1508 if (hend 1509 && (hend->type == bfd_link_hash_defined 1510 || hend->type == bfd_link_hash_defweak)) 1511 { 1512 bfd_vma value = 1513 lm32fdpic_fixup32_section (info)->output_section->vma 1514 + lm32fdpic_fixup32_section (info)->output_offset 1515 + lm32fdpic_fixup32_section (info)->size 1516 - hend->u.def.section->output_section->vma 1517 - hend->u.def.section->output_offset; 1518 BFD_ASSERT (hend->u.def.value == value); 1519 if (hend->u.def.value != value) 1520 { 1521 _bfd_error_handler 1522 ("LINKER BUG: .rofixup section hend->u.def.value != value: %ld != %ld", hend->u.def.value, value); 1523 return FALSE; 1524 } 1525 } 1526 } 1527 1528 return TRUE; 1529 } 1530 1531 /* Finish up dynamic symbol handling. We set the contents of various 1532 dynamic sections here. */ 1533 1534 static bfd_boolean 1535 lm32_elf_finish_dynamic_symbol (bfd *output_bfd, 1536 struct bfd_link_info *info, 1537 struct elf_link_hash_entry *h, 1538 Elf_Internal_Sym *sym) 1539 { 1540 struct elf_lm32_link_hash_table *htab; 1541 bfd_byte *loc; 1542 1543 htab = lm32_elf_hash_table (info); 1544 if (htab == NULL) 1545 return FALSE; 1546 1547 if (h->plt.offset != (bfd_vma) -1) 1548 { 1549 asection *splt; 1550 asection *sgot; 1551 asection *srela; 1552 1553 bfd_vma plt_index; 1554 bfd_vma got_offset; 1555 Elf_Internal_Rela rela; 1556 1557 /* This symbol has an entry in the procedure linkage table. Set 1558 it up. */ 1559 BFD_ASSERT (h->dynindx != -1); 1560 1561 splt = htab->root.splt; 1562 sgot = htab->root.sgotplt; 1563 srela = htab->root.srelplt; 1564 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL); 1565 1566 /* Get the index in the procedure linkage table which 1567 corresponds to this symbol. This is the index of this symbol 1568 in all the symbols for which we are making plt entries. The 1569 first entry in the procedure linkage table is reserved. */ 1570 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1; 1571 1572 /* Get the offset into the .got table of the entry that 1573 corresponds to this function. Each .got entry is 4 bytes. 1574 The first three are reserved. */ 1575 got_offset = (plt_index + 3) * 4; 1576 1577 /* Fill in the entry in the procedure linkage table. */ 1578 if (! bfd_link_pic (info)) 1579 { 1580 /* TODO */ 1581 } 1582 else 1583 { 1584 /* TODO */ 1585 } 1586 1587 /* Fill in the entry in the global offset table. */ 1588 bfd_put_32 (output_bfd, 1589 (splt->output_section->vma 1590 + splt->output_offset 1591 + h->plt.offset 1592 + 12), /* same offset */ 1593 sgot->contents + got_offset); 1594 1595 /* Fill in the entry in the .rela.plt section. */ 1596 rela.r_offset = (sgot->output_section->vma 1597 + sgot->output_offset 1598 + got_offset); 1599 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_JMP_SLOT); 1600 rela.r_addend = 0; 1601 loc = srela->contents; 1602 loc += plt_index * sizeof (Elf32_External_Rela); 1603 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 1604 1605 if (!h->def_regular) 1606 { 1607 /* Mark the symbol as undefined, rather than as defined in 1608 the .plt section. Leave the value alone. */ 1609 sym->st_shndx = SHN_UNDEF; 1610 } 1611 1612 } 1613 1614 if (h->got.offset != (bfd_vma) -1) 1615 { 1616 asection *sgot; 1617 asection *srela; 1618 Elf_Internal_Rela rela; 1619 1620 /* This symbol has an entry in the global offset table. Set it 1621 up. */ 1622 sgot = htab->root.sgot; 1623 srela = htab->root.srelgot; 1624 BFD_ASSERT (sgot != NULL && srela != NULL); 1625 1626 rela.r_offset = (sgot->output_section->vma 1627 + sgot->output_offset 1628 + (h->got.offset &~ 1)); 1629 1630 /* If this is a -Bsymbolic link, and the symbol is defined 1631 locally, we just want to emit a RELATIVE reloc. Likewise if 1632 the symbol was forced to be local because of a version file. 1633 The entry in the global offset table will already have been 1634 initialized in the relocate_section function. */ 1635 if (bfd_link_pic (info) 1636 && (info->symbolic 1637 || h->dynindx == -1 1638 || h->forced_local) 1639 && h->def_regular) 1640 { 1641 rela.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE); 1642 rela.r_addend = (h->root.u.def.value 1643 + h->root.u.def.section->output_section->vma 1644 + h->root.u.def.section->output_offset); 1645 } 1646 else 1647 { 1648 BFD_ASSERT ((h->got.offset & 1) == 0); 1649 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset); 1650 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_GLOB_DAT); 1651 rela.r_addend = 0; 1652 } 1653 1654 loc = srela->contents; 1655 loc += srela->reloc_count * sizeof (Elf32_External_Rela); 1656 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 1657 ++srela->reloc_count; 1658 } 1659 1660 if (h->needs_copy) 1661 { 1662 asection *s; 1663 Elf_Internal_Rela rela; 1664 1665 /* This symbols needs a copy reloc. Set it up. */ 1666 BFD_ASSERT (h->dynindx != -1 1667 && (h->root.type == bfd_link_hash_defined 1668 || h->root.type == bfd_link_hash_defweak)); 1669 1670 s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss"); 1671 BFD_ASSERT (s != NULL); 1672 1673 rela.r_offset = (h->root.u.def.value 1674 + h->root.u.def.section->output_section->vma 1675 + h->root.u.def.section->output_offset); 1676 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_COPY); 1677 rela.r_addend = 0; 1678 loc = s->contents; 1679 loc += s->reloc_count * sizeof (Elf32_External_Rela); 1680 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 1681 ++s->reloc_count; 1682 } 1683 1684 /* Mark some specially defined symbols as absolute. */ 1685 if (h == htab->root.hdynamic || h == htab->root.hgot) 1686 sym->st_shndx = SHN_ABS; 1687 1688 return TRUE; 1689 } 1690 1691 static enum elf_reloc_type_class 1692 lm32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, 1693 const asection *rel_sec ATTRIBUTE_UNUSED, 1694 const Elf_Internal_Rela *rela) 1695 { 1696 switch ((int) ELF32_R_TYPE (rela->r_info)) 1697 { 1698 case R_LM32_RELATIVE: return reloc_class_relative; 1699 case R_LM32_JMP_SLOT: return reloc_class_plt; 1700 case R_LM32_COPY: return reloc_class_copy; 1701 default: return reloc_class_normal; 1702 } 1703 } 1704 1705 /* Adjust a symbol defined by a dynamic object and referenced by a 1706 regular object. The current definition is in some section of the 1707 dynamic object, but we're not including those sections. We have to 1708 change the definition to something the rest of the link can 1709 understand. */ 1710 1711 static bfd_boolean 1712 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 1713 struct elf_link_hash_entry *h) 1714 { 1715 struct elf_lm32_link_hash_table *htab; 1716 struct elf_lm32_link_hash_entry *eh; 1717 struct elf_lm32_dyn_relocs *p; 1718 bfd *dynobj; 1719 asection *s; 1720 1721 dynobj = elf_hash_table (info)->dynobj; 1722 1723 /* Make sure we know what is going on here. */ 1724 BFD_ASSERT (dynobj != NULL 1725 && (h->needs_plt 1726 || h->u.weakdef != NULL 1727 || (h->def_dynamic 1728 && h->ref_regular 1729 && !h->def_regular))); 1730 1731 /* If this is a function, put it in the procedure linkage table. We 1732 will fill in the contents of the procedure linkage table later, 1733 when we know the address of the .got section. */ 1734 if (h->type == STT_FUNC 1735 || h->needs_plt) 1736 { 1737 if (! bfd_link_pic (info) 1738 && !h->def_dynamic 1739 && !h->ref_dynamic 1740 && h->root.type != bfd_link_hash_undefweak 1741 && h->root.type != bfd_link_hash_undefined) 1742 { 1743 /* This case can occur if we saw a PLT reloc in an input 1744 file, but the symbol was never referred to by a dynamic 1745 object. In such a case, we don't actually need to build 1746 a procedure linkage table, and we can just do a PCREL 1747 reloc instead. */ 1748 h->plt.offset = (bfd_vma) -1; 1749 h->needs_plt = 0; 1750 } 1751 1752 return TRUE; 1753 } 1754 else 1755 h->plt.offset = (bfd_vma) -1; 1756 1757 /* If this is a weak symbol, and there is a real definition, the 1758 processor independent code will have arranged for us to see the 1759 real definition first, and we can just use the same value. */ 1760 if (h->u.weakdef != NULL) 1761 { 1762 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 1763 || h->u.weakdef->root.type == bfd_link_hash_defweak); 1764 h->root.u.def.section = h->u.weakdef->root.u.def.section; 1765 h->root.u.def.value = h->u.weakdef->root.u.def.value; 1766 return TRUE; 1767 } 1768 1769 /* This is a reference to a symbol defined by a dynamic object which 1770 is not a function. */ 1771 1772 /* If we are creating a shared library, we must presume that the 1773 only references to the symbol are via the global offset table. 1774 For such cases we need not do anything here; the relocations will 1775 be handled correctly by relocate_section. */ 1776 if (bfd_link_pic (info)) 1777 return TRUE; 1778 1779 /* If there are no references to this symbol that do not use the 1780 GOT, we don't need to generate a copy reloc. */ 1781 if (!h->non_got_ref) 1782 return TRUE; 1783 1784 /* If -z nocopyreloc was given, we won't generate them either. */ 1785 if (info->nocopyreloc) 1786 { 1787 h->non_got_ref = 0; 1788 return TRUE; 1789 } 1790 1791 eh = (struct elf_lm32_link_hash_entry *) h; 1792 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1793 { 1794 s = p->sec->output_section; 1795 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0) 1796 break; 1797 } 1798 1799 /* If we didn't find any dynamic relocs in sections which needs the 1800 copy reloc, then we'll be keeping the dynamic relocs and avoiding 1801 the copy reloc. */ 1802 if (p == NULL) 1803 { 1804 h->non_got_ref = 0; 1805 return TRUE; 1806 } 1807 1808 /* We must allocate the symbol in our .dynbss section, which will 1809 become part of the .bss section of the executable. There will be 1810 an entry for this symbol in the .dynsym section. The dynamic 1811 object will contain position independent code, so all references 1812 from the dynamic object to this symbol will go through the global 1813 offset table. The dynamic linker will use the .dynsym entry to 1814 determine the address it must put in the global offset table, so 1815 both the dynamic object and the regular object will refer to the 1816 same memory location for the variable. */ 1817 1818 htab = lm32_elf_hash_table (info); 1819 if (htab == NULL) 1820 return FALSE; 1821 1822 s = htab->sdynbss; 1823 BFD_ASSERT (s != NULL); 1824 1825 /* We must generate a R_LM32_COPY reloc to tell the dynamic linker 1826 to copy the initial value out of the dynamic object and into the 1827 runtime process image. We need to remember the offset into the 1828 .rela.bss section we are going to use. */ 1829 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 1830 { 1831 asection *srel; 1832 1833 srel = htab->srelbss; 1834 BFD_ASSERT (srel != NULL); 1835 srel->size += sizeof (Elf32_External_Rela); 1836 h->needs_copy = 1; 1837 } 1838 1839 return _bfd_elf_adjust_dynamic_copy (info, h, s); 1840 } 1841 1842 /* Allocate space in .plt, .got and associated reloc sections for 1843 dynamic relocs. */ 1844 1845 static bfd_boolean 1846 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf) 1847 { 1848 struct bfd_link_info *info; 1849 struct elf_lm32_link_hash_table *htab; 1850 struct elf_lm32_link_hash_entry *eh; 1851 struct elf_lm32_dyn_relocs *p; 1852 1853 if (h->root.type == bfd_link_hash_indirect) 1854 return TRUE; 1855 1856 info = (struct bfd_link_info *) inf; 1857 htab = lm32_elf_hash_table (info); 1858 if (htab == NULL) 1859 return FALSE; 1860 1861 eh = (struct elf_lm32_link_hash_entry *) h; 1862 1863 if (htab->root.dynamic_sections_created 1864 && h->plt.refcount > 0) 1865 { 1866 /* Make sure this symbol is output as a dynamic symbol. 1867 Undefined weak syms won't yet be marked as dynamic. */ 1868 if (h->dynindx == -1 1869 && !h->forced_local) 1870 { 1871 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1872 return FALSE; 1873 } 1874 1875 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h)) 1876 { 1877 asection *s = htab->root.splt; 1878 1879 /* If this is the first .plt entry, make room for the special 1880 first entry. */ 1881 if (s->size == 0) 1882 s->size += PLT_ENTRY_SIZE; 1883 1884 h->plt.offset = s->size; 1885 1886 /* If this symbol is not defined in a regular file, and we are 1887 not generating a shared library, then set the symbol to this 1888 location in the .plt. This is required to make function 1889 pointers compare as equal between the normal executable and 1890 the shared library. */ 1891 if (! bfd_link_pic (info) 1892 && !h->def_regular) 1893 { 1894 h->root.u.def.section = s; 1895 h->root.u.def.value = h->plt.offset; 1896 } 1897 1898 /* Make room for this entry. */ 1899 s->size += PLT_ENTRY_SIZE; 1900 1901 /* We also need to make an entry in the .got.plt section, which 1902 will be placed in the .got section by the linker script. */ 1903 htab->root.sgotplt->size += 4; 1904 1905 /* We also need to make an entry in the .rel.plt section. */ 1906 htab->root.srelplt->size += sizeof (Elf32_External_Rela); 1907 } 1908 else 1909 { 1910 h->plt.offset = (bfd_vma) -1; 1911 h->needs_plt = 0; 1912 } 1913 } 1914 else 1915 { 1916 h->plt.offset = (bfd_vma) -1; 1917 h->needs_plt = 0; 1918 } 1919 1920 if (h->got.refcount > 0) 1921 { 1922 asection *s; 1923 bfd_boolean dyn; 1924 1925 /* Make sure this symbol is output as a dynamic symbol. 1926 Undefined weak syms won't yet be marked as dynamic. */ 1927 if (h->dynindx == -1 1928 && !h->forced_local) 1929 { 1930 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1931 return FALSE; 1932 } 1933 1934 s = htab->root.sgot; 1935 1936 h->got.offset = s->size; 1937 s->size += 4; 1938 dyn = htab->root.dynamic_sections_created; 1939 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)) 1940 htab->root.srelgot->size += sizeof (Elf32_External_Rela); 1941 } 1942 else 1943 h->got.offset = (bfd_vma) -1; 1944 1945 if (eh->dyn_relocs == NULL) 1946 return TRUE; 1947 1948 /* In the shared -Bsymbolic case, discard space allocated for 1949 dynamic pc-relative relocs against symbols which turn out to be 1950 defined in regular objects. For the normal shared case, discard 1951 space for pc-relative relocs that have become local due to symbol 1952 visibility changes. */ 1953 1954 if (bfd_link_pic (info)) 1955 { 1956 if (h->def_regular 1957 && (h->forced_local 1958 || info->symbolic)) 1959 { 1960 struct elf_lm32_dyn_relocs **pp; 1961 1962 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;) 1963 { 1964 p->count -= p->pc_count; 1965 p->pc_count = 0; 1966 if (p->count == 0) 1967 *pp = p->next; 1968 else 1969 pp = &p->next; 1970 } 1971 } 1972 1973 /* Also discard relocs on undefined weak syms with non-default 1974 visibility. */ 1975 if (eh->dyn_relocs != NULL 1976 && h->root.type == bfd_link_hash_undefweak) 1977 { 1978 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 1979 eh->dyn_relocs = NULL; 1980 1981 /* Make sure undefined weak symbols are output as a dynamic 1982 symbol in PIEs. */ 1983 else if (h->dynindx == -1 1984 && !h->forced_local) 1985 { 1986 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1987 return FALSE; 1988 } 1989 } 1990 } 1991 else 1992 { 1993 /* For the non-shared case, discard space for relocs against 1994 symbols which turn out to need copy relocs or are not 1995 dynamic. */ 1996 1997 if (!h->non_got_ref 1998 && ((h->def_dynamic 1999 && !h->def_regular) 2000 || (htab->root.dynamic_sections_created 2001 && (h->root.type == bfd_link_hash_undefweak 2002 || h->root.type == bfd_link_hash_undefined)))) 2003 { 2004 /* Make sure this symbol is output as a dynamic symbol. 2005 Undefined weak syms won't yet be marked as dynamic. */ 2006 if (h->dynindx == -1 2007 && !h->forced_local) 2008 { 2009 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2010 return FALSE; 2011 } 2012 2013 /* If that succeeded, we know we'll be keeping all the 2014 relocs. */ 2015 if (h->dynindx != -1) 2016 goto keep; 2017 } 2018 2019 eh->dyn_relocs = NULL; 2020 2021 keep: ; 2022 } 2023 2024 /* Finally, allocate space. */ 2025 for (p = eh->dyn_relocs; p != NULL; p = p->next) 2026 { 2027 asection *sreloc = elf_section_data (p->sec)->sreloc; 2028 sreloc->size += p->count * sizeof (Elf32_External_Rela); 2029 } 2030 2031 return TRUE; 2032 } 2033 2034 /* Find any dynamic relocs that apply to read-only sections. */ 2035 2036 static bfd_boolean 2037 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf) 2038 { 2039 struct elf_lm32_link_hash_entry *eh; 2040 struct elf_lm32_dyn_relocs *p; 2041 2042 eh = (struct elf_lm32_link_hash_entry *) h; 2043 for (p = eh->dyn_relocs; p != NULL; p = p->next) 2044 { 2045 asection *s = p->sec->output_section; 2046 2047 if (s != NULL && (s->flags & SEC_READONLY) != 0) 2048 { 2049 struct bfd_link_info *info = (struct bfd_link_info *) inf; 2050 2051 info->flags |= DF_TEXTREL; 2052 2053 /* Not an error, just cut short the traversal. */ 2054 return FALSE; 2055 } 2056 } 2057 return TRUE; 2058 } 2059 2060 /* Set the sizes of the dynamic sections. */ 2061 2062 static bfd_boolean 2063 lm32_elf_size_dynamic_sections (bfd *output_bfd, 2064 struct bfd_link_info *info) 2065 { 2066 struct elf_lm32_link_hash_table *htab; 2067 bfd *dynobj; 2068 asection *s; 2069 bfd_boolean relocs; 2070 bfd *ibfd; 2071 2072 htab = lm32_elf_hash_table (info); 2073 if (htab == NULL) 2074 return FALSE; 2075 2076 dynobj = htab->root.dynobj; 2077 BFD_ASSERT (dynobj != NULL); 2078 2079 if (htab->root.dynamic_sections_created) 2080 { 2081 /* Set the contents of the .interp section to the interpreter. */ 2082 if (bfd_link_executable (info) && !info->nointerp) 2083 { 2084 s = bfd_get_linker_section (dynobj, ".interp"); 2085 BFD_ASSERT (s != NULL); 2086 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 2087 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 2088 } 2089 } 2090 2091 /* Set up .got offsets for local syms, and space for local dynamic 2092 relocs. */ 2093 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 2094 { 2095 bfd_signed_vma *local_got; 2096 bfd_signed_vma *end_local_got; 2097 bfd_size_type locsymcount; 2098 Elf_Internal_Shdr *symtab_hdr; 2099 asection *srel; 2100 2101 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour) 2102 continue; 2103 2104 for (s = ibfd->sections; s != NULL; s = s->next) 2105 { 2106 struct elf_lm32_dyn_relocs *p; 2107 2108 for (p = ((struct elf_lm32_dyn_relocs *) 2109 elf_section_data (s)->local_dynrel); 2110 p != NULL; 2111 p = p->next) 2112 { 2113 if (! bfd_is_abs_section (p->sec) 2114 && bfd_is_abs_section (p->sec->output_section)) 2115 { 2116 /* Input section has been discarded, either because 2117 it is a copy of a linkonce section or due to 2118 linker script /DISCARD/, so we'll be discarding 2119 the relocs too. */ 2120 } 2121 else if (p->count != 0) 2122 { 2123 srel = elf_section_data (p->sec)->sreloc; 2124 srel->size += p->count * sizeof (Elf32_External_Rela); 2125 if ((p->sec->output_section->flags & SEC_READONLY) != 0) 2126 info->flags |= DF_TEXTREL; 2127 } 2128 } 2129 } 2130 2131 local_got = elf_local_got_refcounts (ibfd); 2132 if (!local_got) 2133 continue; 2134 2135 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 2136 locsymcount = symtab_hdr->sh_info; 2137 end_local_got = local_got + locsymcount; 2138 s = htab->root.sgot; 2139 srel = htab->root.srelgot; 2140 for (; local_got < end_local_got; ++local_got) 2141 { 2142 if (*local_got > 0) 2143 { 2144 *local_got = s->size; 2145 s->size += 4; 2146 if (bfd_link_pic (info)) 2147 srel->size += sizeof (Elf32_External_Rela); 2148 } 2149 else 2150 *local_got = (bfd_vma) -1; 2151 } 2152 } 2153 2154 /* Allocate global sym .plt and .got entries, and space for global 2155 sym dynamic relocs. */ 2156 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info); 2157 2158 /* We now have determined the sizes of the various dynamic sections. 2159 Allocate memory for them. */ 2160 relocs = FALSE; 2161 for (s = dynobj->sections; s != NULL; s = s->next) 2162 { 2163 if ((s->flags & SEC_LINKER_CREATED) == 0) 2164 continue; 2165 2166 if (s == htab->root.splt 2167 || s == htab->root.sgot 2168 || s == htab->root.sgotplt 2169 || s == htab->sdynbss) 2170 { 2171 /* Strip this section if we don't need it; see the 2172 comment below. */ 2173 } 2174 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela")) 2175 { 2176 if (s->size != 0 && s != htab->root.srelplt) 2177 relocs = TRUE; 2178 2179 /* We use the reloc_count field as a counter if we need 2180 to copy relocs into the output file. */ 2181 s->reloc_count = 0; 2182 } 2183 else 2184 /* It's not one of our sections, so don't allocate space. */ 2185 continue; 2186 2187 if (s->size == 0) 2188 { 2189 /* If we don't need this section, strip it from the 2190 output file. This is mostly to handle .rela.bss and 2191 .rela.plt. We must create both sections in 2192 create_dynamic_sections, because they must be created 2193 before the linker maps input sections to output 2194 sections. The linker does that before 2195 adjust_dynamic_symbol is called, and it is that 2196 function which decides whether anything needs to go 2197 into these sections. */ 2198 s->flags |= SEC_EXCLUDE; 2199 continue; 2200 } 2201 2202 if ((s->flags & SEC_HAS_CONTENTS) == 0) 2203 continue; 2204 2205 /* Allocate memory for the section contents. We use bfd_zalloc 2206 here in case unused entries are not reclaimed before the 2207 section's contents are written out. This should not happen, 2208 but this way if it does, we get a R_LM32_NONE reloc instead 2209 of garbage. */ 2210 s->contents = bfd_zalloc (dynobj, s->size); 2211 if (s->contents == NULL) 2212 return FALSE; 2213 } 2214 2215 if (htab->root.dynamic_sections_created) 2216 { 2217 /* Add some entries to the .dynamic section. We fill in the 2218 values later, in lm32_elf_finish_dynamic_sections, but we 2219 must add the entries now so that we get the correct size for 2220 the .dynamic section. The DT_DEBUG entry is filled in by the 2221 dynamic linker and used by the debugger. */ 2222 #define add_dynamic_entry(TAG, VAL) \ 2223 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 2224 2225 if (bfd_link_executable (info)) 2226 { 2227 if (! add_dynamic_entry (DT_DEBUG, 0)) 2228 return FALSE; 2229 } 2230 2231 if (htab->root.splt->size != 0) 2232 { 2233 if (! add_dynamic_entry (DT_PLTGOT, 0) 2234 || ! add_dynamic_entry (DT_PLTRELSZ, 0) 2235 || ! add_dynamic_entry (DT_PLTREL, DT_RELA) 2236 || ! add_dynamic_entry (DT_JMPREL, 0)) 2237 return FALSE; 2238 } 2239 2240 if (relocs) 2241 { 2242 if (! add_dynamic_entry (DT_RELA, 0) 2243 || ! add_dynamic_entry (DT_RELASZ, 0) 2244 || ! add_dynamic_entry (DT_RELAENT, 2245 sizeof (Elf32_External_Rela))) 2246 return FALSE; 2247 2248 /* If any dynamic relocs apply to a read-only section, 2249 then we need a DT_TEXTREL entry. */ 2250 if ((info->flags & DF_TEXTREL) == 0) 2251 elf_link_hash_traverse (&htab->root, readonly_dynrelocs, 2252 info); 2253 2254 if ((info->flags & DF_TEXTREL) != 0) 2255 { 2256 if (! add_dynamic_entry (DT_TEXTREL, 0)) 2257 return FALSE; 2258 } 2259 } 2260 } 2261 #undef add_dynamic_entry 2262 2263 /* Allocate .rofixup section. */ 2264 if (IS_FDPIC (output_bfd)) 2265 { 2266 struct weak_symbol_list *list_start = NULL, *list_end = NULL; 2267 int rgot_weak_count = 0; 2268 int r32_count = 0; 2269 int rgot_count = 0; 2270 /* Look for deleted sections. */ 2271 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 2272 { 2273 for (s = ibfd->sections; s != NULL; s = s->next) 2274 { 2275 if (s->reloc_count) 2276 { 2277 /* Count relocs that need .rofixup entires. */ 2278 Elf_Internal_Rela *internal_relocs, *end; 2279 internal_relocs = elf_section_data (s)->relocs; 2280 if (internal_relocs == NULL) 2281 internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE)); 2282 if (internal_relocs != NULL) 2283 { 2284 end = internal_relocs + s->reloc_count; 2285 while (internal_relocs < end) 2286 { 2287 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 2288 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd); 2289 unsigned long r_symndx; 2290 struct elf_link_hash_entry *h; 2291 2292 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 2293 sym_hashes = elf_sym_hashes (ibfd); 2294 r_symndx = ELF32_R_SYM (internal_relocs->r_info); 2295 h = NULL; 2296 if (r_symndx < symtab_hdr->sh_info) 2297 { 2298 } 2299 else 2300 { 2301 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 2302 while (h->root.type == bfd_link_hash_indirect 2303 || h->root.type == bfd_link_hash_warning) 2304 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2305 } 2306 2307 /* Don't generate entries for weak symbols. */ 2308 if (!h || (h && h->root.type != bfd_link_hash_undefweak)) 2309 { 2310 if (!discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0)) 2311 { 2312 switch (ELF32_R_TYPE (internal_relocs->r_info)) 2313 { 2314 case R_LM32_32: 2315 r32_count++; 2316 break; 2317 case R_LM32_16_GOT: 2318 rgot_count++; 2319 break; 2320 } 2321 } 2322 } 2323 else 2324 { 2325 struct weak_symbol_list *current, *new_entry; 2326 /* Is this symbol already in the list? */ 2327 for (current = list_start; current; current = current->next) 2328 { 2329 if (!strcmp (current->name, h->root.root.string)) 2330 break; 2331 } 2332 if (!current && !discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC)) 2333 { 2334 /* Will this have an entry in the GOT. */ 2335 if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT) 2336 { 2337 /* Create a new entry. */ 2338 new_entry = malloc (sizeof (struct weak_symbol_list)); 2339 if (!new_entry) 2340 return FALSE; 2341 new_entry->name = h->root.root.string; 2342 new_entry->next = NULL; 2343 /* Add to list */ 2344 if (list_start == NULL) 2345 { 2346 list_start = new_entry; 2347 list_end = new_entry; 2348 } 2349 else 2350 { 2351 list_end->next = new_entry; 2352 list_end = new_entry; 2353 } 2354 /* Increase count of undefined weak symbols in the got. */ 2355 rgot_weak_count++; 2356 } 2357 } 2358 } 2359 internal_relocs++; 2360 } 2361 } 2362 else 2363 return FALSE; 2364 } 2365 } 2366 } 2367 /* Free list. */ 2368 while (list_start) 2369 { 2370 list_end = list_start->next; 2371 free (list_start); 2372 list_start = list_end; 2373 } 2374 2375 /* Size sections. */ 2376 lm32fdpic_fixup32_section (info)->size 2377 = (r32_count + (htab->root.sgot->size / 4) - rgot_weak_count + 1) * 4; 2378 if (lm32fdpic_fixup32_section (info)->size == 0) 2379 lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE; 2380 else 2381 { 2382 lm32fdpic_fixup32_section (info)->contents = 2383 bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size); 2384 if (lm32fdpic_fixup32_section (info)->contents == NULL) 2385 return FALSE; 2386 } 2387 } 2388 2389 return TRUE; 2390 } 2391 2392 /* Create dynamic sections when linking against a dynamic object. */ 2393 2394 static bfd_boolean 2395 lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 2396 { 2397 struct elf_lm32_link_hash_table *htab; 2398 flagword flags, pltflags; 2399 asection *s; 2400 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 2401 int ptralign = 2; /* 32bit */ 2402 2403 htab = lm32_elf_hash_table (info); 2404 if (htab == NULL) 2405 return FALSE; 2406 2407 /* Make sure we have a GOT - For the case where we have a dynamic object 2408 but none of the relocs in check_relocs */ 2409 if (!_bfd_elf_create_got_section (abfd, info)) 2410 return FALSE; 2411 if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL)) 2412 { 2413 if (! create_rofixup_section (abfd, info)) 2414 return FALSE; 2415 } 2416 2417 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and 2418 .rel[a].bss sections. */ 2419 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 2420 | SEC_LINKER_CREATED); 2421 2422 pltflags = flags; 2423 pltflags |= SEC_CODE; 2424 if (bed->plt_not_loaded) 2425 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS); 2426 if (bed->plt_readonly) 2427 pltflags |= SEC_READONLY; 2428 2429 s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags); 2430 htab->root.splt = s; 2431 if (s == NULL 2432 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment)) 2433 return FALSE; 2434 2435 if (bed->want_plt_sym) 2436 { 2437 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the 2438 .plt section. */ 2439 struct bfd_link_hash_entry *bh = NULL; 2440 struct elf_link_hash_entry *h; 2441 2442 if (! (_bfd_generic_link_add_one_symbol 2443 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 2444 (bfd_vma) 0, NULL, FALSE, 2445 get_elf_backend_data (abfd)->collect, &bh))) 2446 return FALSE; 2447 h = (struct elf_link_hash_entry *) bh; 2448 h->def_regular = 1; 2449 h->type = STT_OBJECT; 2450 htab->root.hplt = h; 2451 2452 if (bfd_link_pic (info) 2453 && ! bfd_elf_link_record_dynamic_symbol (info, h)) 2454 return FALSE; 2455 } 2456 2457 s = bfd_make_section_anyway_with_flags (abfd, 2458 bed->default_use_rela_p 2459 ? ".rela.plt" : ".rel.plt", 2460 flags | SEC_READONLY); 2461 htab->root.srelplt = s; 2462 if (s == NULL 2463 || ! bfd_set_section_alignment (abfd, s, ptralign)) 2464 return FALSE; 2465 2466 if (htab->root.sgot == NULL 2467 && !_bfd_elf_create_got_section (abfd, info)) 2468 return FALSE; 2469 2470 if (bed->want_dynbss) 2471 { 2472 /* The .dynbss section is a place to put symbols which are defined 2473 by dynamic objects, are referenced by regular objects, and are 2474 not functions. We must allocate space for them in the process 2475 image and use a R_*_COPY reloc to tell the dynamic linker to 2476 initialize them at run time. The linker script puts the .dynbss 2477 section into the .bss section of the final image. */ 2478 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss", 2479 SEC_ALLOC | SEC_LINKER_CREATED); 2480 htab->sdynbss = s; 2481 if (s == NULL) 2482 return FALSE; 2483 /* The .rel[a].bss section holds copy relocs. This section is not 2484 normally needed. We need to create it here, though, so that the 2485 linker will map it to an output section. We can't just create it 2486 only if we need it, because we will not know whether we need it 2487 until we have seen all the input files, and the first time the 2488 main linker code calls BFD after examining all the input files 2489 (size_dynamic_sections) the input sections have already been 2490 mapped to the output sections. If the section turns out not to 2491 be needed, we can discard it later. We will never need this 2492 section when generating a shared object, since they do not use 2493 copy relocs. */ 2494 if (! bfd_link_pic (info)) 2495 { 2496 s = bfd_make_section_anyway_with_flags (abfd, 2497 (bed->default_use_rela_p 2498 ? ".rela.bss" : ".rel.bss"), 2499 flags | SEC_READONLY); 2500 htab->srelbss = s; 2501 if (s == NULL 2502 || ! bfd_set_section_alignment (abfd, s, ptralign)) 2503 return FALSE; 2504 } 2505 } 2506 2507 return TRUE; 2508 } 2509 2510 /* Copy the extra info we tack onto an elf_link_hash_entry. */ 2511 2512 static void 2513 lm32_elf_copy_indirect_symbol (struct bfd_link_info *info, 2514 struct elf_link_hash_entry *dir, 2515 struct elf_link_hash_entry *ind) 2516 { 2517 struct elf_lm32_link_hash_entry * edir; 2518 struct elf_lm32_link_hash_entry * eind; 2519 2520 edir = (struct elf_lm32_link_hash_entry *) dir; 2521 eind = (struct elf_lm32_link_hash_entry *) ind; 2522 2523 if (eind->dyn_relocs != NULL) 2524 { 2525 if (edir->dyn_relocs != NULL) 2526 { 2527 struct elf_lm32_dyn_relocs **pp; 2528 struct elf_lm32_dyn_relocs *p; 2529 2530 /* Add reloc counts against the indirect sym to the direct sym 2531 list. Merge any entries against the same section. */ 2532 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;) 2533 { 2534 struct elf_lm32_dyn_relocs *q; 2535 2536 for (q = edir->dyn_relocs; q != NULL; q = q->next) 2537 if (q->sec == p->sec) 2538 { 2539 q->pc_count += p->pc_count; 2540 q->count += p->count; 2541 *pp = p->next; 2542 break; 2543 } 2544 if (q == NULL) 2545 pp = &p->next; 2546 } 2547 *pp = edir->dyn_relocs; 2548 } 2549 2550 edir->dyn_relocs = eind->dyn_relocs; 2551 eind->dyn_relocs = NULL; 2552 } 2553 2554 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 2555 } 2556 2557 static bfd_boolean 2558 lm32_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info) 2559 { 2560 if (!bfd_link_relocatable (info)) 2561 { 2562 if (!bfd_elf_stack_segment_size (output_bfd, info, 2563 "__stacksize", DEFAULT_STACK_SIZE)) 2564 return FALSE; 2565 2566 asection *sec = bfd_get_section_by_name (output_bfd, ".stack"); 2567 if (sec) 2568 sec->size = info->stacksize >= 0 ? info->stacksize : 0; 2569 } 2570 2571 return TRUE; 2572 } 2573 2574 static bfd_boolean 2575 lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd) 2576 { 2577 unsigned i; 2578 2579 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 2580 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 2581 return TRUE; 2582 2583 if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd)) 2584 return FALSE; 2585 2586 if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr 2587 || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr) 2588 return TRUE; 2589 2590 /* Copy the stack size. */ 2591 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++) 2592 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK) 2593 { 2594 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i]; 2595 2596 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++) 2597 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK) 2598 { 2599 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr)); 2600 2601 /* Rewrite the phdrs, since we're only called after they were first written. */ 2602 if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd) 2603 ->s->sizeof_ehdr, SEEK_SET) != 0 2604 || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr, 2605 elf_elfheader (obfd)->e_phnum) != 0) 2606 return FALSE; 2607 break; 2608 } 2609 2610 break; 2611 } 2612 2613 return TRUE; 2614 } 2615 2616 2617 #define ELF_ARCH bfd_arch_lm32 2618 #define ELF_TARGET_ID LM32_ELF_DATA 2619 #define ELF_MACHINE_CODE EM_LATTICEMICO32 2620 #define ELF_MAXPAGESIZE 0x1000 2621 2622 #define TARGET_BIG_SYM lm32_elf32_vec 2623 #define TARGET_BIG_NAME "elf32-lm32" 2624 2625 #define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup 2626 #define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup 2627 #define elf_info_to_howto lm32_info_to_howto_rela 2628 #define elf_info_to_howto_rel 0 2629 #define elf_backend_rela_normal 1 2630 #define elf_backend_object_p lm32_elf_object_p 2631 #define elf_backend_final_write_processing lm32_elf_final_write_processing 2632 #define elf_backend_stack_align 8 2633 #define elf_backend_can_gc_sections 1 2634 #define elf_backend_can_refcount 1 2635 #define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook 2636 #define elf_backend_gc_sweep_hook lm32_elf_gc_sweep_hook 2637 #define elf_backend_plt_readonly 1 2638 #define elf_backend_want_got_plt 1 2639 #define elf_backend_want_plt_sym 0 2640 #define elf_backend_got_header_size 12 2641 #define elf_backend_dtrel_excludes_plt 1 2642 #define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create 2643 #define elf_backend_check_relocs lm32_elf_check_relocs 2644 #define elf_backend_reloc_type_class lm32_elf_reloc_type_class 2645 #define elf_backend_copy_indirect_symbol lm32_elf_copy_indirect_symbol 2646 #define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections 2647 #define elf_backend_omit_section_dynsym ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true) 2648 #define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections 2649 #define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections 2650 #define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol 2651 #define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol 2652 #define elf_backend_relocate_section lm32_elf_relocate_section 2653 2654 #include "elf32-target.h" 2655 2656 #undef ELF_MAXPAGESIZE 2657 #define ELF_MAXPAGESIZE 0x4000 2658 2659 2660 #undef TARGET_BIG_SYM 2661 #define TARGET_BIG_SYM lm32_elf32_fdpic_vec 2662 #undef TARGET_BIG_NAME 2663 #define TARGET_BIG_NAME "elf32-lm32fdpic" 2664 #undef elf32_bed 2665 #define elf32_bed elf32_lm32fdpic_bed 2666 2667 #undef elf_backend_always_size_sections 2668 #define elf_backend_always_size_sections lm32_elf_always_size_sections 2669 #undef bfd_elf32_bfd_copy_private_bfd_data 2670 #define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data 2671 2672 #include "elf32-target.h" 2673