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