1 /* i370-specific support for 32-bit ELF 2 Copyright 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004 3 Free Software Foundation, Inc. 4 Written by Ian Lance Taylor, Cygnus Support. 5 Hacked by Linas Vepstas for i370 linas@linas.org 6 7 This file is part of BFD, the Binary File Descriptor library. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 22 23 /* This file is based on a preliminary PowerPC ELF ABI. 24 But its been hacked on for the IBM 360/370 architectures. 25 Basically, the 31bit relocation works, and just about everything 26 else is a wild card. In particular, don't expect shared libs or 27 dynamic loading to work ... its never been tested ... 28 */ 29 30 #include "bfd.h" 31 #include "sysdep.h" 32 #include "bfdlink.h" 33 #include "libbfd.h" 34 #include "elf-bfd.h" 35 #include "elf/i370.h" 36 37 static reloc_howto_type *i370_elf_howto_table[ (int)R_I370_max ]; 38 39 static reloc_howto_type i370_elf_howto_raw[] = 40 { 41 /* This reloc does nothing. */ 42 HOWTO (R_I370_NONE, /* type */ 43 0, /* rightshift */ 44 2, /* size (0 = byte, 1 = short, 2 = long) */ 45 32, /* bitsize */ 46 FALSE, /* pc_relative */ 47 0, /* bitpos */ 48 complain_overflow_bitfield, /* complain_on_overflow */ 49 bfd_elf_generic_reloc, /* special_function */ 50 "R_I370_NONE", /* name */ 51 FALSE, /* partial_inplace */ 52 0, /* src_mask */ 53 0, /* dst_mask */ 54 FALSE), /* pcrel_offset */ 55 56 /* A standard 31 bit relocation. */ 57 HOWTO (R_I370_ADDR31, /* type */ 58 0, /* rightshift */ 59 2, /* size (0 = byte, 1 = short, 2 = long) */ 60 31, /* bitsize */ 61 FALSE, /* pc_relative */ 62 0, /* bitpos */ 63 complain_overflow_bitfield, /* complain_on_overflow */ 64 bfd_elf_generic_reloc, /* special_function */ 65 "R_I370_ADDR31", /* name */ 66 FALSE, /* partial_inplace */ 67 0, /* src_mask */ 68 0x7fffffff, /* dst_mask */ 69 FALSE), /* pcrel_offset */ 70 71 /* A standard 32 bit relocation. */ 72 HOWTO (R_I370_ADDR32, /* type */ 73 0, /* rightshift */ 74 2, /* size (0 = byte, 1 = short, 2 = long) */ 75 32, /* bitsize */ 76 FALSE, /* pc_relative */ 77 0, /* bitpos */ 78 complain_overflow_bitfield, /* complain_on_overflow */ 79 bfd_elf_generic_reloc, /* special_function */ 80 "R_I370_ADDR32", /* name */ 81 FALSE, /* partial_inplace */ 82 0, /* src_mask */ 83 0xffffffff, /* dst_mask */ 84 FALSE), /* pcrel_offset */ 85 86 /* A standard 16 bit relocation. */ 87 HOWTO (R_I370_ADDR16, /* type */ 88 0, /* rightshift */ 89 1, /* size (0 = byte, 1 = short, 2 = long) */ 90 16, /* bitsize */ 91 FALSE, /* pc_relative */ 92 0, /* bitpos */ 93 complain_overflow_bitfield, /* complain_on_overflow */ 94 bfd_elf_generic_reloc, /* special_function */ 95 "R_I370_ADDR16", /* name */ 96 FALSE, /* partial_inplace */ 97 0, /* src_mask */ 98 0xffff, /* dst_mask */ 99 FALSE), /* pcrel_offset */ 100 101 /* 31-bit PC relative */ 102 HOWTO (R_I370_REL31, /* type */ 103 0, /* rightshift */ 104 2, /* size (0 = byte, 1 = short, 2 = long) */ 105 31, /* bitsize */ 106 TRUE, /* pc_relative */ 107 0, /* bitpos */ 108 complain_overflow_bitfield, /* complain_on_overflow */ 109 bfd_elf_generic_reloc, /* special_function */ 110 "R_I370_REL31", /* name */ 111 FALSE, /* partial_inplace */ 112 0, /* src_mask */ 113 0x7fffffff, /* dst_mask */ 114 TRUE), /* pcrel_offset */ 115 116 /* 32-bit PC relative */ 117 HOWTO (R_I370_REL32, /* type */ 118 0, /* rightshift */ 119 2, /* size (0 = byte, 1 = short, 2 = long) */ 120 32, /* bitsize */ 121 TRUE, /* pc_relative */ 122 0, /* bitpos */ 123 complain_overflow_bitfield, /* complain_on_overflow */ 124 bfd_elf_generic_reloc, /* special_function */ 125 "R_I370_REL32", /* name */ 126 FALSE, /* partial_inplace */ 127 0, /* src_mask */ 128 0xffffffff, /* dst_mask */ 129 TRUE), /* pcrel_offset */ 130 131 /* A standard 12 bit relocation. */ 132 HOWTO (R_I370_ADDR12, /* type */ 133 0, /* rightshift */ 134 1, /* size (0 = byte, 1 = short, 2 = long) */ 135 12, /* bitsize */ 136 FALSE, /* pc_relative */ 137 0, /* bitpos */ 138 complain_overflow_bitfield, /* complain_on_overflow */ 139 bfd_elf_generic_reloc, /* special_function */ 140 "R_I370_ADDR12", /* name */ 141 FALSE, /* partial_inplace */ 142 0, /* src_mask */ 143 0xfff, /* dst_mask */ 144 FALSE), /* pcrel_offset */ 145 146 /* 12-bit PC relative */ 147 HOWTO (R_I370_REL12, /* type */ 148 0, /* rightshift */ 149 1, /* size (0 = byte, 1 = short, 2 = long) */ 150 12, /* bitsize */ 151 TRUE, /* pc_relative */ 152 0, /* bitpos */ 153 complain_overflow_bitfield, /* complain_on_overflow */ 154 bfd_elf_generic_reloc, /* special_function */ 155 "R_I370_REL12", /* name */ 156 FALSE, /* partial_inplace */ 157 0, /* src_mask */ 158 0xfff, /* dst_mask */ 159 TRUE), /* pcrel_offset */ 160 161 /* A standard 8 bit relocation. */ 162 HOWTO (R_I370_ADDR8, /* type */ 163 0, /* rightshift */ 164 0, /* size (0 = byte, 1 = short, 2 = long) */ 165 8, /* bitsize */ 166 FALSE, /* pc_relative */ 167 0, /* bitpos */ 168 complain_overflow_bitfield, /* complain_on_overflow */ 169 bfd_elf_generic_reloc, /* special_function */ 170 "R_I370_ADDR8", /* name */ 171 FALSE, /* partial_inplace */ 172 0, /* src_mask */ 173 0xff, /* dst_mask */ 174 FALSE), /* pcrel_offset */ 175 176 /* 8-bit PC relative */ 177 HOWTO (R_I370_REL8, /* type */ 178 0, /* rightshift */ 179 0, /* size (0 = byte, 1 = short, 2 = long) */ 180 8, /* bitsize */ 181 TRUE, /* pc_relative */ 182 0, /* bitpos */ 183 complain_overflow_bitfield, /* complain_on_overflow */ 184 bfd_elf_generic_reloc, /* special_function */ 185 "R_I370_REL8", /* name */ 186 FALSE, /* partial_inplace */ 187 0, /* src_mask */ 188 0xff, /* dst_mask */ 189 TRUE), /* pcrel_offset */ 190 191 /* This is used only by the dynamic linker. The symbol should exist 192 both in the object being run and in some shared library. The 193 dynamic linker copies the data addressed by the symbol from the 194 shared library into the object, because the object being 195 run has to have the data at some particular address. */ 196 HOWTO (R_I370_COPY, /* type */ 197 0, /* rightshift */ 198 2, /* size (0 = byte, 1 = short, 2 = long) */ 199 32, /* bitsize */ 200 FALSE, /* pc_relative */ 201 0, /* bitpos */ 202 complain_overflow_bitfield, /* complain_on_overflow */ 203 bfd_elf_generic_reloc, /* special_function */ 204 "R_I370_COPY", /* name */ 205 FALSE, /* partial_inplace */ 206 0, /* src_mask */ 207 0, /* dst_mask */ 208 FALSE), /* pcrel_offset */ 209 210 /* Used only by the dynamic linker. When the object is run, this 211 longword is set to the load address of the object, plus the 212 addend. */ 213 HOWTO (R_I370_RELATIVE, /* type */ 214 0, /* rightshift */ 215 2, /* size (0 = byte, 1 = short, 2 = long) */ 216 32, /* bitsize */ 217 FALSE, /* pc_relative */ 218 0, /* bitpos */ 219 complain_overflow_bitfield, /* complain_on_overflow */ 220 bfd_elf_generic_reloc, /* special_function */ 221 "R_I370_RELATIVE", /* name */ 222 FALSE, /* partial_inplace */ 223 0, /* src_mask */ 224 0xffffffff, /* dst_mask */ 225 FALSE), /* pcrel_offset */ 226 227 }; 228 229 static void i370_elf_howto_init 230 PARAMS ((void)); 231 static reloc_howto_type *i370_elf_reloc_type_lookup 232 PARAMS ((bfd *, bfd_reloc_code_real_type)); 233 static void i370_elf_info_to_howto 234 PARAMS ((bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst)); 235 static bfd_boolean i370_elf_set_private_flags 236 PARAMS ((bfd *, flagword)); 237 238 /* Initialize the i370_elf_howto_table, so that linear accesses can be done. */ 239 240 static void 241 i370_elf_howto_init () 242 { 243 unsigned int i, type; 244 245 for (i = 0; i < sizeof (i370_elf_howto_raw) / sizeof (i370_elf_howto_raw[0]); i++) 246 { 247 type = i370_elf_howto_raw[i].type; 248 BFD_ASSERT (type < sizeof (i370_elf_howto_table) / sizeof (i370_elf_howto_table[0])); 249 i370_elf_howto_table[type] = &i370_elf_howto_raw[i]; 250 } 251 } 252 253 static reloc_howto_type * 254 i370_elf_reloc_type_lookup (abfd, code) 255 bfd *abfd ATTRIBUTE_UNUSED; 256 bfd_reloc_code_real_type code; 257 { 258 enum i370_reloc_type i370_reloc = R_I370_NONE; 259 260 if (!i370_elf_howto_table[ R_I370_ADDR31 ]) /* Initialize howto table if needed */ 261 i370_elf_howto_init (); 262 263 switch ((int)code) 264 { 265 default: 266 return (reloc_howto_type *)NULL; 267 268 case BFD_RELOC_NONE: i370_reloc = R_I370_NONE; break; 269 case BFD_RELOC_32: i370_reloc = R_I370_ADDR31; break; 270 case BFD_RELOC_16: i370_reloc = R_I370_ADDR16; break; 271 case BFD_RELOC_32_PCREL: i370_reloc = R_I370_REL31; break; 272 case BFD_RELOC_CTOR: i370_reloc = R_I370_ADDR31; break; 273 case BFD_RELOC_I370_D12: i370_reloc = R_I370_ADDR12; break; 274 } 275 276 return i370_elf_howto_table[ (int)i370_reloc ]; 277 }; 278 279 static bfd_boolean i370_elf_merge_private_bfd_data 280 PARAMS ((bfd *, bfd *)); 281 static bfd_boolean i370_elf_relocate_section 282 PARAMS ((bfd *, struct bfd_link_info *info, bfd *, asection *, bfd_byte *, 283 Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms, 284 asection **)); 285 static void i370_elf_post_process_headers 286 PARAMS ((bfd *, struct bfd_link_info *)); 287 static bfd_boolean i370_elf_create_dynamic_sections 288 PARAMS ((bfd *, struct bfd_link_info *)); 289 static bfd_boolean i370_elf_section_from_shdr 290 PARAMS ((bfd *, Elf_Internal_Shdr *, const char *)); 291 static bfd_boolean i370_elf_fake_sections 292 PARAMS ((bfd *, Elf_Internal_Shdr *, asection *)); 293 static bfd_boolean i370_elf_check_relocs 294 PARAMS ((bfd *, struct bfd_link_info *, asection *, 295 const Elf_Internal_Rela *)); 296 static bfd_boolean i370_elf_adjust_dynamic_symbol 297 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); 298 static bfd_boolean i370_elf_adjust_dynindx 299 PARAMS ((struct elf_link_hash_entry *, PTR)); 300 static bfd_boolean i370_elf_size_dynamic_sections 301 PARAMS ((bfd *, struct bfd_link_info *)); 302 static bfd_boolean i370_elf_finish_dynamic_sections 303 PARAMS ((bfd *, struct bfd_link_info *)); 304 305 /* The name of the dynamic interpreter. This is put in the .interp 306 section. */ 307 308 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so" 309 310 /* Set the howto pointer for an i370 ELF reloc. */ 311 312 static void 313 i370_elf_info_to_howto (abfd, cache_ptr, dst) 314 bfd *abfd ATTRIBUTE_UNUSED; 315 arelent *cache_ptr; 316 Elf_Internal_Rela *dst; 317 { 318 if (!i370_elf_howto_table[ R_I370_ADDR31 ]) /* Initialize howto table */ 319 i370_elf_howto_init (); 320 321 BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_I370_max); 322 cache_ptr->howto = i370_elf_howto_table[ELF32_R_TYPE (dst->r_info)]; 323 } 324 325 /* hack alert -- the following several routines look generic to me ... 326 * why are we bothering with them ??? 327 */ 328 /* Function to set whether a module needs the -mrelocatable bit set. */ 329 static bfd_boolean 330 i370_elf_set_private_flags (abfd, flags) 331 bfd *abfd; 332 flagword flags; 333 { 334 BFD_ASSERT (!elf_flags_init (abfd) 335 || elf_elfheader (abfd)->e_flags == flags); 336 337 elf_elfheader (abfd)->e_flags = flags; 338 elf_flags_init (abfd) = TRUE; 339 return TRUE; 340 } 341 342 /* Merge backend specific data from an object file to the output 343 object file when linking */ 344 static bfd_boolean 345 i370_elf_merge_private_bfd_data (ibfd, obfd) 346 bfd *ibfd; 347 bfd *obfd; 348 { 349 flagword old_flags; 350 flagword new_flags; 351 352 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 353 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 354 return TRUE; 355 356 new_flags = elf_elfheader (ibfd)->e_flags; 357 old_flags = elf_elfheader (obfd)->e_flags; 358 if (!elf_flags_init (obfd)) /* First call, no flags set */ 359 { 360 elf_flags_init (obfd) = TRUE; 361 elf_elfheader (obfd)->e_flags = new_flags; 362 } 363 364 else if (new_flags == old_flags) /* Compatible flags are ok */ 365 ; 366 367 else /* Incompatible flags */ 368 { 369 (*_bfd_error_handler) 370 ("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)", 371 bfd_archive_filename (ibfd), (long) new_flags, (long) old_flags); 372 373 bfd_set_error (bfd_error_bad_value); 374 return FALSE; 375 } 376 377 return TRUE; 378 } 379 380 /* Handle an i370 specific section when reading an object file. This 381 is called when elfcode.h finds a section with an unknown type. */ 382 /* XXX hack alert bogus This routine is mostly all junk and almost 383 * certainly does the wrong thing. Its here simply because it does 384 * just enough to allow glibc-2.1 ld.so to compile & link. 385 */ 386 387 static bfd_boolean 388 i370_elf_section_from_shdr (abfd, hdr, name) 389 bfd *abfd; 390 Elf_Internal_Shdr *hdr; 391 const char *name; 392 { 393 asection *newsect; 394 flagword flags; 395 396 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name)) 397 return FALSE; 398 399 newsect = hdr->bfd_section; 400 flags = bfd_get_section_flags (abfd, newsect); 401 if (hdr->sh_flags & SHF_EXCLUDE) 402 flags |= SEC_EXCLUDE; 403 404 if (hdr->sh_type == SHT_ORDERED) 405 flags |= SEC_SORT_ENTRIES; 406 407 bfd_set_section_flags (abfd, newsect, flags); 408 return TRUE; 409 } 410 411 /* Set up any other section flags and such that may be necessary. */ 412 /* XXX hack alert bogus This routine is mostly all junk and almost 413 * certainly does the wrong thing. Its here simply because it does 414 * just enough to allow glibc-2.1 ld.so to compile & link. 415 */ 416 417 static bfd_boolean 418 i370_elf_fake_sections (abfd, shdr, asect) 419 bfd *abfd ATTRIBUTE_UNUSED; 420 Elf_Internal_Shdr *shdr; 421 asection *asect; 422 { 423 if ((asect->flags & SEC_EXCLUDE) != 0) 424 shdr->sh_flags |= SHF_EXCLUDE; 425 426 if ((asect->flags & SEC_SORT_ENTRIES) != 0) 427 shdr->sh_type = SHT_ORDERED; 428 429 return TRUE; 430 } 431 432 /* We have to create .dynsbss and .rela.sbss here so that they get mapped 433 to output sections (just like _bfd_elf_create_dynamic_sections has 434 to create .dynbss and .rela.bss). */ 435 /* XXX hack alert bogus This routine is mostly all junk and almost 436 * certainly does the wrong thing. Its here simply because it does 437 * just enough to allow glibc-2.1 ld.so to compile & link. 438 */ 439 440 static bfd_boolean 441 i370_elf_create_dynamic_sections (abfd, info) 442 bfd *abfd; 443 struct bfd_link_info *info; 444 { 445 register asection *s; 446 flagword flags; 447 448 if (!_bfd_elf_create_dynamic_sections(abfd, info)) 449 return FALSE; 450 451 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 452 | SEC_LINKER_CREATED); 453 454 s = bfd_make_section (abfd, ".dynsbss"); 455 if (s == NULL 456 || ! bfd_set_section_flags (abfd, s, SEC_ALLOC)) 457 return FALSE; 458 459 if (! info->shared) 460 { 461 s = bfd_make_section (abfd, ".rela.sbss"); 462 if (s == NULL 463 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY) 464 || ! bfd_set_section_alignment (abfd, s, 2)) 465 return FALSE; 466 } 467 468 /* xxx beats me, seem to need a rela.text ... */ 469 s = bfd_make_section (abfd, ".rela.text"); 470 if (s == NULL 471 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY) 472 || ! bfd_set_section_alignment (abfd, s, 2)) 473 return FALSE; 474 return TRUE; 475 } 476 477 /* Adjust a symbol defined by a dynamic object and referenced by a 478 regular object. The current definition is in some section of the 479 dynamic object, but we're not including those sections. We have to 480 change the definition to something the rest of the link can 481 understand. */ 482 /* XXX hack alert bogus This routine is mostly all junk and almost 483 * certainly does the wrong thing. Its here simply because it does 484 * just enough to allow glibc-2.1 ld.so to compile & link. 485 */ 486 487 static bfd_boolean 488 i370_elf_adjust_dynamic_symbol (info, h) 489 struct bfd_link_info *info; 490 struct elf_link_hash_entry *h; 491 { 492 bfd *dynobj = elf_hash_table (info)->dynobj; 493 asection *s; 494 unsigned int power_of_two; 495 496 #ifdef DEBUG 497 fprintf (stderr, "i370_elf_adjust_dynamic_symbol called for %s\n", 498 h->root.root.string); 499 #endif 500 501 /* Make sure we know what is going on here. */ 502 BFD_ASSERT (dynobj != NULL 503 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) 504 || h->weakdef != NULL 505 || ((h->elf_link_hash_flags 506 & ELF_LINK_HASH_DEF_DYNAMIC) != 0 507 && (h->elf_link_hash_flags 508 & ELF_LINK_HASH_REF_REGULAR) != 0 509 && (h->elf_link_hash_flags 510 & ELF_LINK_HASH_DEF_REGULAR) == 0))); 511 512 s = bfd_get_section_by_name (dynobj, ".rela.text"); 513 BFD_ASSERT (s != NULL); 514 s->_raw_size += sizeof (Elf32_External_Rela); 515 516 /* If this is a weak symbol, and there is a real definition, the 517 processor independent code will have arranged for us to see the 518 real definition first, and we can just use the same value. */ 519 if (h->weakdef != NULL) 520 { 521 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined 522 || h->weakdef->root.type == bfd_link_hash_defweak); 523 h->root.u.def.section = h->weakdef->root.u.def.section; 524 h->root.u.def.value = h->weakdef->root.u.def.value; 525 return TRUE; 526 } 527 528 /* This is a reference to a symbol defined by a dynamic object which 529 is not a function. */ 530 531 /* If we are creating a shared library, we must presume that the 532 only references to the symbol are via the global offset table. 533 For such cases we need not do anything here; the relocations will 534 be handled correctly by relocate_section. */ 535 if (info->shared) 536 return TRUE; 537 538 /* We must allocate the symbol in our .dynbss section, which will 539 become part of the .bss section of the executable. There will be 540 an entry for this symbol in the .dynsym section. The dynamic 541 object will contain position independent code, so all references 542 from the dynamic object to this symbol will go through the global 543 offset table. The dynamic linker will use the .dynsym entry to 544 determine the address it must put in the global offset table, so 545 both the dynamic object and the regular object will refer to the 546 same memory location for the variable. 547 548 Of course, if the symbol is sufficiently small, we must instead 549 allocate it in .sbss. FIXME: It would be better to do this if and 550 only if there were actually SDAREL relocs for that symbol. */ 551 552 if (h->size <= elf_gp_size (dynobj)) 553 s = bfd_get_section_by_name (dynobj, ".dynsbss"); 554 else 555 s = bfd_get_section_by_name (dynobj, ".dynbss"); 556 BFD_ASSERT (s != NULL); 557 558 /* We must generate a R_I370_COPY reloc to tell the dynamic linker to 559 copy the initial value out of the dynamic object and into the 560 runtime process image. We need to remember the offset into the 561 .rela.bss section we are going to use. */ 562 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 563 { 564 asection *srel; 565 566 if (h->size <= elf_gp_size (dynobj)) 567 srel = bfd_get_section_by_name (dynobj, ".rela.sbss"); 568 else 569 srel = bfd_get_section_by_name (dynobj, ".rela.bss"); 570 BFD_ASSERT (srel != NULL); 571 srel->_raw_size += sizeof (Elf32_External_Rela); 572 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY; 573 } 574 575 /* We need to figure out the alignment required for this symbol. I 576 have no idea how ELF linkers handle this. */ 577 power_of_two = bfd_log2 (h->size); 578 if (power_of_two > 4) 579 power_of_two = 4; 580 581 /* Apply the required alignment. */ 582 s->_raw_size = BFD_ALIGN (s->_raw_size, 583 (bfd_size_type) (1 << power_of_two)); 584 if (power_of_two > bfd_get_section_alignment (dynobj, s)) 585 { 586 if (! bfd_set_section_alignment (dynobj, s, power_of_two)) 587 return FALSE; 588 } 589 590 /* Define the symbol as being at this point in the section. */ 591 h->root.u.def.section = s; 592 h->root.u.def.value = s->_raw_size; 593 594 /* Increment the section size to make room for the symbol. */ 595 s->_raw_size += h->size; 596 597 return TRUE; 598 } 599 600 /* Increment the index of a dynamic symbol by a given amount. Called 601 via elf_link_hash_traverse. */ 602 /* XXX hack alert bogus This routine is mostly all junk and almost 603 * certainly does the wrong thing. Its here simply because it does 604 * just enough to allow glibc-2.1 ld.so to compile & link. 605 */ 606 607 static bfd_boolean 608 i370_elf_adjust_dynindx (h, cparg) 609 struct elf_link_hash_entry *h; 610 PTR cparg; 611 { 612 int *cp = (int *) cparg; 613 614 #ifdef DEBUG 615 fprintf (stderr, 616 "i370_elf_adjust_dynindx called, h->dynindx = %d, *cp = %d\n", 617 h->dynindx, *cp); 618 #endif 619 620 if (h->root.type == bfd_link_hash_warning) 621 h = (struct elf_link_hash_entry *) h->root.u.i.link; 622 623 if (h->dynindx != -1) 624 h->dynindx += *cp; 625 626 return TRUE; 627 } 628 629 /* Set the sizes of the dynamic sections. */ 630 /* XXX hack alert bogus This routine is mostly all junk and almost 631 * certainly does the wrong thing. Its here simply because it does 632 * just enough to allow glibc-2.1 ld.so to compile & link. 633 */ 634 635 static bfd_boolean 636 i370_elf_size_dynamic_sections (output_bfd, info) 637 bfd *output_bfd; 638 struct bfd_link_info *info; 639 { 640 bfd *dynobj; 641 asection *s; 642 bfd_boolean plt; 643 bfd_boolean relocs; 644 bfd_boolean reltext; 645 646 #ifdef DEBUG 647 fprintf (stderr, "i370_elf_size_dynamic_sections called\n"); 648 #endif 649 650 dynobj = elf_hash_table (info)->dynobj; 651 BFD_ASSERT (dynobj != NULL); 652 653 if (elf_hash_table (info)->dynamic_sections_created) 654 { 655 /* Set the contents of the .interp section to the interpreter. */ 656 if (info->executable) 657 { 658 s = bfd_get_section_by_name (dynobj, ".interp"); 659 BFD_ASSERT (s != NULL); 660 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER; 661 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 662 } 663 } 664 else 665 { 666 /* We may have created entries in the .rela.got, .rela.sdata, and 667 .rela.sdata2 sections. However, if we are not creating the 668 dynamic sections, we will not actually use these entries. Reset 669 the size of .rela.got, et al, which will cause it to get 670 stripped from the output file below. */ 671 static char *rela_sections[] = { ".rela.got", ".rela.sdata", 672 ".rela.sdata2", ".rela.sbss", 673 (char *)0 }; 674 char **p; 675 676 for (p = rela_sections; *p != (char *)0; p++) 677 { 678 s = bfd_get_section_by_name (dynobj, *p); 679 if (s != NULL) 680 s->_raw_size = 0; 681 } 682 } 683 684 /* The check_relocs and adjust_dynamic_symbol entry points have 685 determined the sizes of the various dynamic sections. Allocate 686 memory for them. */ 687 plt = FALSE; 688 relocs = FALSE; 689 reltext = FALSE; 690 for (s = dynobj->sections; s != NULL; s = s->next) 691 { 692 const char *name; 693 bfd_boolean strip; 694 695 if ((s->flags & SEC_LINKER_CREATED) == 0) 696 continue; 697 698 /* It's OK to base decisions on the section name, because none 699 of the dynobj section names depend upon the input files. */ 700 name = bfd_get_section_name (dynobj, s); 701 strip = FALSE; 702 703 if (strcmp (name, ".plt") == 0) 704 { 705 if (s->_raw_size == 0) 706 { 707 /* Strip this section if we don't need it; see the 708 comment below. */ 709 strip = TRUE; 710 } 711 else 712 { 713 /* Remember whether there is a PLT. */ 714 plt = TRUE; 715 } 716 } 717 else if (strncmp (name, ".rela", 5) == 0) 718 { 719 if (s->_raw_size == 0) 720 { 721 /* If we don't need this section, strip it from the 722 output file. This is mostly to handle .rela.bss and 723 .rela.plt. We must create both sections in 724 create_dynamic_sections, because they must be created 725 before the linker maps input sections to output 726 sections. The linker does that before 727 adjust_dynamic_symbol is called, and it is that 728 function which decides whether anything needs to go 729 into these sections. */ 730 strip = TRUE; 731 } 732 else 733 { 734 asection *target; 735 const char *outname; 736 737 /* Remember whether there are any relocation sections. */ 738 relocs = TRUE; 739 740 /* If this relocation section applies to a read only 741 section, then we probably need a DT_TEXTREL entry. */ 742 outname = bfd_get_section_name (output_bfd, 743 s->output_section); 744 target = bfd_get_section_by_name (output_bfd, outname + 5); 745 if (target != NULL 746 && (target->flags & SEC_READONLY) != 0 747 && (target->flags & SEC_ALLOC) != 0) 748 reltext = TRUE; 749 750 /* We use the reloc_count field as a counter if we need 751 to copy relocs into the output file. */ 752 s->reloc_count = 0; 753 } 754 } 755 else if (strcmp (name, ".got") != 0 756 && strcmp (name, ".sdata") != 0 757 && strcmp (name, ".sdata2") != 0) 758 { 759 /* It's not one of our sections, so don't allocate space. */ 760 continue; 761 } 762 763 if (strip) 764 { 765 asection **spp; 766 767 for (spp = &s->output_section->owner->sections; 768 *spp != NULL; 769 spp = &(*spp)->next) 770 { 771 if (*spp == s->output_section) 772 { 773 bfd_section_list_remove (s->output_section->owner, spp); 774 --s->output_section->owner->section_count; 775 break; 776 } 777 } 778 continue; 779 } 780 /* Allocate memory for the section contents. */ 781 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size); 782 if (s->contents == NULL && s->_raw_size != 0) 783 return FALSE; 784 } 785 786 if (elf_hash_table (info)->dynamic_sections_created) 787 { 788 /* Add some entries to the .dynamic section. We fill in the 789 values later, in i370_elf_finish_dynamic_sections, but we 790 must add the entries now so that we get the correct size for 791 the .dynamic section. The DT_DEBUG entry is filled in by the 792 dynamic linker and used by the debugger. */ 793 #define add_dynamic_entry(TAG, VAL) \ 794 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 795 796 if (!info->shared) 797 { 798 if (!add_dynamic_entry (DT_DEBUG, 0)) 799 return FALSE; 800 } 801 802 if (plt) 803 { 804 if (!add_dynamic_entry (DT_PLTGOT, 0) 805 || !add_dynamic_entry (DT_PLTRELSZ, 0) 806 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 807 || !add_dynamic_entry (DT_JMPREL, 0)) 808 return FALSE; 809 } 810 811 if (relocs) 812 { 813 if (!add_dynamic_entry (DT_RELA, 0) 814 || !add_dynamic_entry (DT_RELASZ, 0) 815 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))) 816 return FALSE; 817 } 818 819 if (reltext) 820 { 821 if (!add_dynamic_entry (DT_TEXTREL, 0)) 822 return FALSE; 823 info->flags |= DF_TEXTREL; 824 } 825 } 826 #undef add_dynamic_entry 827 828 /* If we are generating a shared library, we generate a section 829 symbol for each output section. These are local symbols, which 830 means that they must come first in the dynamic symbol table. 831 That means we must increment the dynamic symbol index of every 832 other dynamic symbol. 833 834 FIXME: We assume that there will never be relocations to 835 locations in linker-created sections that do not have 836 externally-visible names. Instead, we should work out precisely 837 which sections relocations are targeted at. */ 838 if (info->shared) 839 { 840 int c; 841 842 for (c = 0, s = output_bfd->sections; s != NULL; s = s->next) 843 { 844 if ((s->flags & SEC_LINKER_CREATED) != 0 845 || (s->flags & SEC_ALLOC) == 0) 846 { 847 elf_section_data (s)->dynindx = -1; 848 continue; 849 } 850 851 /* These symbols will have no names, so we don't need to 852 fiddle with dynstr_index. */ 853 854 elf_section_data (s)->dynindx = c + 1; 855 856 c++; 857 } 858 859 elf_link_hash_traverse (elf_hash_table (info), 860 i370_elf_adjust_dynindx, 861 (PTR) &c); 862 elf_hash_table (info)->dynsymcount += c; 863 } 864 865 return TRUE; 866 } 867 868 /* Look through the relocs for a section during the first phase, and 869 allocate space in the global offset table or procedure linkage 870 table. */ 871 /* XXX hack alert bogus This routine is mostly all junk and almost 872 * certainly does the wrong thing. Its here simply because it does 873 * just enough to allow glibc-2.1 ld.so to compile & link. 874 */ 875 876 static bfd_boolean 877 i370_elf_check_relocs (abfd, info, sec, relocs) 878 bfd *abfd; 879 struct bfd_link_info *info; 880 asection *sec; 881 const Elf_Internal_Rela *relocs; 882 { 883 bfd *dynobj; 884 Elf_Internal_Shdr *symtab_hdr; 885 struct elf_link_hash_entry **sym_hashes; 886 const Elf_Internal_Rela *rel; 887 const Elf_Internal_Rela *rel_end; 888 bfd_vma *local_got_offsets; 889 asection *sreloc; 890 891 if (info->relocatable) 892 return TRUE; 893 894 #ifdef DEBUG 895 fprintf (stderr, "i370_elf_check_relocs called for section %s in %s\n", 896 bfd_get_section_name (abfd, sec), 897 bfd_archive_filename (abfd)); 898 #endif 899 900 dynobj = elf_hash_table (info)->dynobj; 901 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 902 sym_hashes = elf_sym_hashes (abfd); 903 local_got_offsets = elf_local_got_offsets (abfd); 904 905 sreloc = NULL; 906 907 rel_end = relocs + sec->reloc_count; 908 for (rel = relocs; rel < rel_end; rel++) 909 { 910 unsigned long r_symndx; 911 struct elf_link_hash_entry *h; 912 913 r_symndx = ELF32_R_SYM (rel->r_info); 914 if (r_symndx < symtab_hdr->sh_info) 915 h = NULL; 916 else 917 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 918 919 if (info->shared) 920 { 921 #ifdef DEBUG 922 fprintf (stderr, 923 "i370_elf_check_relocs needs to create relocation for %s\n", 924 (h && h->root.root.string) 925 ? h->root.root.string : "<unknown>"); 926 #endif 927 if (sreloc == NULL) 928 { 929 const char *name; 930 931 name = (bfd_elf_string_from_elf_section 932 (abfd, 933 elf_elfheader (abfd)->e_shstrndx, 934 elf_section_data (sec)->rel_hdr.sh_name)); 935 if (name == NULL) 936 return FALSE; 937 938 BFD_ASSERT (strncmp (name, ".rela", 5) == 0 939 && strcmp (bfd_get_section_name (abfd, sec), name + 5) == 0); 940 941 sreloc = bfd_get_section_by_name (dynobj, name); 942 if (sreloc == NULL) 943 { 944 flagword flags; 945 946 sreloc = bfd_make_section (dynobj, name); 947 flags = (SEC_HAS_CONTENTS | SEC_READONLY 948 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 949 if ((sec->flags & SEC_ALLOC) != 0) 950 flags |= SEC_ALLOC | SEC_LOAD; 951 if (sreloc == NULL 952 || ! bfd_set_section_flags (dynobj, sreloc, flags) 953 || ! bfd_set_section_alignment (dynobj, sreloc, 2)) 954 return FALSE; 955 } 956 } 957 958 sreloc->_raw_size += sizeof (Elf32_External_Rela); 959 960 /* FIXME: We should here do what the m68k and i386 961 backends do: if the reloc is pc-relative, record it 962 in case it turns out that the reloc is unnecessary 963 because the symbol is forced local by versioning or 964 we are linking with -Bdynamic. Fortunately this 965 case is not frequent. */ 966 } 967 } 968 969 return TRUE; 970 } 971 972 /* Finish up the dynamic sections. */ 973 /* XXX hack alert bogus This routine is mostly all junk and almost 974 * certainly does the wrong thing. Its here simply because it does 975 * just enough to allow glibc-2.1 ld.so to compile & link. 976 */ 977 978 static bfd_boolean 979 i370_elf_finish_dynamic_sections (output_bfd, info) 980 bfd *output_bfd; 981 struct bfd_link_info *info; 982 { 983 asection *sdyn; 984 bfd *dynobj = elf_hash_table (info)->dynobj; 985 asection *sgot = bfd_get_section_by_name (dynobj, ".got"); 986 987 #ifdef DEBUG 988 fprintf (stderr, "i370_elf_finish_dynamic_sections called\n"); 989 #endif 990 991 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 992 993 if (elf_hash_table (info)->dynamic_sections_created) 994 { 995 asection *splt; 996 Elf32_External_Dyn *dyncon, *dynconend; 997 998 splt = bfd_get_section_by_name (dynobj, ".plt"); 999 BFD_ASSERT (splt != NULL && sdyn != NULL); 1000 1001 dyncon = (Elf32_External_Dyn *) sdyn->contents; 1002 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size); 1003 for (; dyncon < dynconend; dyncon++) 1004 { 1005 Elf_Internal_Dyn dyn; 1006 const char *name; 1007 bfd_boolean size; 1008 1009 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 1010 1011 switch (dyn.d_tag) 1012 { 1013 case DT_PLTGOT: name = ".plt"; size = FALSE; break; 1014 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break; 1015 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break; 1016 default: name = NULL; size = FALSE; break; 1017 } 1018 1019 if (name != NULL) 1020 { 1021 asection *s; 1022 1023 s = bfd_get_section_by_name (output_bfd, name); 1024 if (s == NULL) 1025 dyn.d_un.d_val = 0; 1026 else 1027 { 1028 if (! size) 1029 dyn.d_un.d_ptr = s->vma; 1030 else 1031 { 1032 if (s->_cooked_size != 0) 1033 dyn.d_un.d_val = s->_cooked_size; 1034 else 1035 dyn.d_un.d_val = s->_raw_size; 1036 } 1037 } 1038 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 1039 } 1040 } 1041 } 1042 1043 /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can 1044 easily find the address of the _GLOBAL_OFFSET_TABLE_. */ 1045 /* XXX this is clearly very wrong for the 370 arch */ 1046 if (sgot) 1047 { 1048 unsigned char *contents = sgot->contents; 1049 bfd_put_32 (output_bfd, (bfd_vma) 0x4e800021 /* blrl */, contents); 1050 1051 if (sdyn == NULL) 1052 bfd_put_32 (output_bfd, (bfd_vma) 0, contents+4); 1053 else 1054 bfd_put_32 (output_bfd, 1055 sdyn->output_section->vma + sdyn->output_offset, 1056 contents+4); 1057 1058 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 1059 } 1060 1061 if (info->shared) 1062 { 1063 asection *sdynsym; 1064 asection *s; 1065 Elf_Internal_Sym sym; 1066 int maxdindx = 0; 1067 1068 /* Set up the section symbols for the output sections. */ 1069 1070 sdynsym = bfd_get_section_by_name (dynobj, ".dynsym"); 1071 BFD_ASSERT (sdynsym != NULL); 1072 1073 sym.st_size = 0; 1074 sym.st_name = 0; 1075 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION); 1076 sym.st_other = 0; 1077 1078 for (s = output_bfd->sections; s != NULL; s = s->next) 1079 { 1080 int indx, dindx; 1081 Elf32_External_Sym *esym; 1082 1083 sym.st_value = s->vma; 1084 1085 indx = elf_section_data (s)->this_idx; 1086 dindx = elf_section_data (s)->dynindx; 1087 if (dindx != -1) 1088 { 1089 BFD_ASSERT(indx > 0); 1090 BFD_ASSERT(dindx > 0); 1091 1092 if (dindx > maxdindx) 1093 maxdindx = dindx; 1094 1095 sym.st_shndx = indx; 1096 1097 esym = (Elf32_External_Sym *) sdynsym->contents + dindx; 1098 bfd_elf32_swap_symbol_out (output_bfd, &sym, (PTR) esym, (PTR) 0); 1099 } 1100 } 1101 1102 /* Set the sh_info field of the output .dynsym section to the 1103 index of the first global symbol. */ 1104 elf_section_data (sdynsym->output_section)->this_hdr.sh_info = 1105 maxdindx + 1; 1106 } 1107 1108 return TRUE; 1109 } 1110 1111 /* The RELOCATE_SECTION function is called by the ELF backend linker 1112 to handle the relocations for a section. 1113 1114 The relocs are always passed as Rela structures; if the section 1115 actually uses Rel structures, the r_addend field will always be 1116 zero. 1117 1118 This function is responsible for adjust the section contents as 1119 necessary, and (if using Rela relocs and generating a 1120 relocatable output file) adjusting the reloc addend as 1121 necessary. 1122 1123 This function does not have to worry about setting the reloc 1124 address or the reloc symbol index. 1125 1126 LOCAL_SYMS is a pointer to the swapped in local symbols. 1127 1128 LOCAL_SECTIONS is an array giving the section in the input file 1129 corresponding to the st_shndx field of each local symbol. 1130 1131 The global hash table entry for the global symbols can be found 1132 via elf_sym_hashes (input_bfd). 1133 1134 When generating relocatable output, this function must handle 1135 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 1136 going to be the section symbol corresponding to the output 1137 section, which means that the addend must be adjusted 1138 accordingly. */ 1139 1140 static bfd_boolean 1141 i370_elf_relocate_section (output_bfd, info, input_bfd, input_section, 1142 contents, relocs, local_syms, local_sections) 1143 bfd *output_bfd; 1144 struct bfd_link_info *info; 1145 bfd *input_bfd; 1146 asection *input_section; 1147 bfd_byte *contents; 1148 Elf_Internal_Rela *relocs; 1149 Elf_Internal_Sym *local_syms; 1150 asection **local_sections; 1151 { 1152 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1153 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd); 1154 bfd *dynobj = elf_hash_table (info)->dynobj; 1155 Elf_Internal_Rela *rel = relocs; 1156 Elf_Internal_Rela *relend = relocs + input_section->reloc_count; 1157 asection *sreloc = NULL; 1158 bfd_vma *local_got_offsets; 1159 bfd_boolean ret = TRUE; 1160 1161 if (info->relocatable) 1162 return TRUE; 1163 1164 #ifdef DEBUG 1165 fprintf (stderr, "i370_elf_relocate_section called for %s section %s, %ld relocations%s\n", 1166 bfd_archive_filename (input_bfd), 1167 bfd_section_name(input_bfd, input_section), 1168 (long) input_section->reloc_count, 1169 (info->relocatable) ? " (relocatable)" : ""); 1170 #endif 1171 1172 if (!i370_elf_howto_table[ R_I370_ADDR31 ]) /* Initialize howto table if needed */ 1173 i370_elf_howto_init (); 1174 1175 local_got_offsets = elf_local_got_offsets (input_bfd); 1176 1177 for (; rel < relend; rel++) 1178 { 1179 enum i370_reloc_type r_type = (enum i370_reloc_type)ELF32_R_TYPE (rel->r_info); 1180 bfd_vma offset = rel->r_offset; 1181 bfd_vma addend = rel->r_addend; 1182 bfd_reloc_status_type r = bfd_reloc_other; 1183 Elf_Internal_Sym *sym = (Elf_Internal_Sym *)0; 1184 asection *sec = (asection *)0; 1185 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *)0; 1186 const char *sym_name = (const char *)0; 1187 reloc_howto_type *howto; 1188 unsigned long r_symndx; 1189 bfd_vma relocation; 1190 1191 /* Unknown relocation handling */ 1192 if ((unsigned)r_type >= (unsigned)R_I370_max 1193 || !i370_elf_howto_table[(int)r_type]) 1194 { 1195 (*_bfd_error_handler) ("%s: unknown relocation type %d", 1196 bfd_archive_filename (input_bfd), 1197 (int) r_type); 1198 1199 bfd_set_error (bfd_error_bad_value); 1200 ret = FALSE; 1201 continue; 1202 } 1203 1204 howto = i370_elf_howto_table[(int)r_type]; 1205 r_symndx = ELF32_R_SYM (rel->r_info); 1206 1207 if (r_symndx < symtab_hdr->sh_info) 1208 { 1209 sym = local_syms + r_symndx; 1210 sec = local_sections[r_symndx]; 1211 sym_name = "<local symbol>"; 1212 1213 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 1214 addend = rel->r_addend; 1215 } 1216 else 1217 { 1218 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1219 while (h->root.type == bfd_link_hash_indirect 1220 || h->root.type == bfd_link_hash_warning) 1221 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1222 sym_name = h->root.root.string; 1223 if (h->root.type == bfd_link_hash_defined 1224 || h->root.type == bfd_link_hash_defweak) 1225 { 1226 sec = h->root.u.def.section; 1227 if (info->shared 1228 && ((! info->symbolic && h->dynindx != -1) 1229 || (h->elf_link_hash_flags 1230 & ELF_LINK_HASH_DEF_REGULAR) == 0) 1231 && (input_section->flags & SEC_ALLOC) != 0 1232 && (r_type == R_I370_ADDR31 1233 || r_type == R_I370_COPY 1234 || r_type == R_I370_ADDR16 1235 || r_type == R_I370_RELATIVE)) 1236 { 1237 /* In these cases, we don't need the relocation 1238 value. We check specially because in some 1239 obscure cases sec->output_section will be NULL. */ 1240 relocation = 0; 1241 } 1242 else 1243 relocation = (h->root.u.def.value 1244 + sec->output_section->vma 1245 + sec->output_offset); 1246 } 1247 else if (h->root.type == bfd_link_hash_undefweak) 1248 relocation = 0; 1249 else if (info->unresolved_syms_in_objects == RM_IGNORE 1250 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 1251 relocation = 0; 1252 else 1253 { 1254 if ((*info->callbacks->undefined_symbol) 1255 (info, h->root.root.string, input_bfd, 1256 input_section, rel->r_offset, 1257 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR 1258 || ELF_ST_VISIBILITY (h->other)))) 1259 { 1260 ret = FALSE; 1261 continue; 1262 } 1263 relocation = 0; 1264 } 1265 } 1266 1267 switch ((int) r_type) 1268 { 1269 default: 1270 (*_bfd_error_handler) 1271 ("%s: unknown relocation type %d for symbol %s", 1272 bfd_archive_filename (input_bfd), 1273 (int) r_type, sym_name); 1274 1275 bfd_set_error (bfd_error_bad_value); 1276 ret = FALSE; 1277 continue; 1278 1279 case (int)R_I370_NONE: 1280 continue; 1281 1282 /* Relocations that may need to be propagated if this is a shared 1283 object. */ 1284 case (int)R_I370_REL31: 1285 /* If these relocations are not to a named symbol, they can be 1286 handled right here, no need to bother the dynamic linker. */ 1287 if (h == NULL 1288 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 1289 break; 1290 /* fall through */ 1291 1292 /* Relocations that always need to be propagated if this is a shared 1293 object. */ 1294 case (int)R_I370_ADDR31: 1295 case (int)R_I370_ADDR16: 1296 if (info->shared 1297 && r_symndx != 0) 1298 { 1299 Elf_Internal_Rela outrel; 1300 bfd_byte *loc; 1301 int skip; 1302 1303 #ifdef DEBUG 1304 fprintf (stderr, 1305 "i370_elf_relocate_section needs to create relocation for %s\n", 1306 (h && h->root.root.string) ? h->root.root.string : "<unknown>"); 1307 #endif 1308 1309 /* When generating a shared object, these relocations 1310 are copied into the output file to be resolved at run 1311 time. */ 1312 1313 if (sreloc == NULL) 1314 { 1315 const char *name; 1316 1317 name = (bfd_elf_string_from_elf_section 1318 (input_bfd, 1319 elf_elfheader (input_bfd)->e_shstrndx, 1320 elf_section_data (input_section)->rel_hdr.sh_name)); 1321 if (name == NULL) 1322 return FALSE; 1323 1324 BFD_ASSERT (strncmp (name, ".rela", 5) == 0 1325 && strcmp (bfd_get_section_name (input_bfd, 1326 input_section), 1327 name + 5) == 0); 1328 1329 sreloc = bfd_get_section_by_name (dynobj, name); 1330 BFD_ASSERT (sreloc != NULL); 1331 } 1332 1333 skip = 0; 1334 1335 outrel.r_offset = 1336 _bfd_elf_section_offset (output_bfd, info, input_section, 1337 rel->r_offset); 1338 if (outrel.r_offset == (bfd_vma) -1 1339 || outrel.r_offset == (bfd_vma) -2) 1340 skip = (int) outrel.r_offset; 1341 outrel.r_offset += (input_section->output_section->vma 1342 + input_section->output_offset); 1343 1344 if (skip) 1345 memset (&outrel, 0, sizeof outrel); 1346 /* h->dynindx may be -1 if this symbol was marked to 1347 become local. */ 1348 else if (h != NULL 1349 && ((! info->symbolic && h->dynindx != -1) 1350 || (h->elf_link_hash_flags 1351 & ELF_LINK_HASH_DEF_REGULAR) == 0)) 1352 { 1353 BFD_ASSERT (h->dynindx != -1); 1354 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 1355 outrel.r_addend = rel->r_addend; 1356 } 1357 else 1358 { 1359 if (r_type == R_I370_ADDR31) 1360 { 1361 outrel.r_info = ELF32_R_INFO (0, R_I370_RELATIVE); 1362 outrel.r_addend = relocation + rel->r_addend; 1363 } 1364 else 1365 { 1366 long indx; 1367 1368 if (bfd_is_abs_section (sec)) 1369 indx = 0; 1370 else if (sec == NULL || sec->owner == NULL) 1371 { 1372 bfd_set_error (bfd_error_bad_value); 1373 return FALSE; 1374 } 1375 else 1376 { 1377 asection *osec; 1378 1379 osec = sec->output_section; 1380 indx = elf_section_data (osec)->dynindx; 1381 BFD_ASSERT(indx > 0); 1382 #ifdef DEBUG 1383 if (indx <= 0) 1384 { 1385 printf ("indx=%d section=%s flags=%08x name=%s\n", 1386 indx, osec->name, osec->flags, 1387 h->root.root.string); 1388 } 1389 #endif 1390 } 1391 1392 outrel.r_info = ELF32_R_INFO (indx, r_type); 1393 outrel.r_addend = relocation + rel->r_addend; 1394 } 1395 } 1396 1397 loc = sreloc->contents; 1398 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela); 1399 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 1400 1401 /* This reloc will be computed at runtime, so there's no 1402 need to do anything now, unless this is a RELATIVE 1403 reloc in an unallocated section. */ 1404 if (skip == -1 1405 || (input_section->flags & SEC_ALLOC) != 0 1406 || ELF32_R_TYPE (outrel.r_info) != R_I370_RELATIVE) 1407 continue; 1408 } 1409 break; 1410 1411 case (int)R_I370_COPY: 1412 case (int)R_I370_RELATIVE: 1413 (*_bfd_error_handler) 1414 ("%s: Relocation %s is not yet supported for symbol %s.", 1415 bfd_archive_filename (input_bfd), 1416 i370_elf_howto_table[(int) r_type]->name, 1417 sym_name); 1418 1419 bfd_set_error (bfd_error_invalid_operation); 1420 ret = FALSE; 1421 continue; 1422 } 1423 1424 #ifdef DEBUG 1425 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n", 1426 howto->name, 1427 (int)r_type, 1428 sym_name, 1429 r_symndx, 1430 (long)offset, 1431 (long)addend); 1432 #endif 1433 1434 r = _bfd_final_link_relocate (howto, 1435 input_bfd, 1436 input_section, 1437 contents, 1438 offset, 1439 relocation, 1440 addend); 1441 1442 if (r != bfd_reloc_ok) 1443 { 1444 ret = FALSE; 1445 switch (r) 1446 { 1447 default: 1448 break; 1449 1450 case bfd_reloc_overflow: 1451 { 1452 const char *name; 1453 1454 if (h != NULL) 1455 name = h->root.root.string; 1456 else 1457 { 1458 name = bfd_elf_string_from_elf_section (input_bfd, 1459 symtab_hdr->sh_link, 1460 sym->st_name); 1461 if (name == NULL) 1462 break; 1463 1464 if (*name == '\0') 1465 name = bfd_section_name (input_bfd, sec); 1466 } 1467 1468 (*info->callbacks->reloc_overflow) (info, 1469 name, 1470 howto->name, 1471 (bfd_vma) 0, 1472 input_bfd, 1473 input_section, 1474 offset); 1475 } 1476 break; 1477 1478 } 1479 } 1480 } 1481 1482 #ifdef DEBUG 1483 fprintf (stderr, "\n"); 1484 #endif 1485 1486 return ret; 1487 } 1488 1489 static void 1490 i370_elf_post_process_headers (abfd, link_info) 1491 bfd * abfd; 1492 struct bfd_link_info * link_info ATTRIBUTE_UNUSED; 1493 { 1494 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */ 1495 1496 i_ehdrp = elf_elfheader (abfd); 1497 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_LINUX; 1498 } 1499 1500 #define TARGET_BIG_SYM bfd_elf32_i370_vec 1501 #define TARGET_BIG_NAME "elf32-i370" 1502 #define ELF_ARCH bfd_arch_i370 1503 #define ELF_MACHINE_CODE EM_S370 1504 #ifdef EM_I370_OLD 1505 #define ELF_MACHINE_ALT1 EM_I370_OLD 1506 #endif 1507 #define ELF_MAXPAGESIZE 0x1000 1508 #define elf_info_to_howto i370_elf_info_to_howto 1509 1510 #define elf_backend_plt_not_loaded 1 1511 #define elf_backend_got_symbol_offset 4 1512 #define elf_backend_rela_normal 1 1513 1514 #define bfd_elf32_bfd_reloc_type_lookup i370_elf_reloc_type_lookup 1515 #define bfd_elf32_bfd_set_private_flags i370_elf_set_private_flags 1516 #define bfd_elf32_bfd_merge_private_bfd_data i370_elf_merge_private_bfd_data 1517 #define elf_backend_relocate_section i370_elf_relocate_section 1518 1519 /* dynamic loader support is mostly broken; just enough here to be able to 1520 * link glibc's ld.so without errors. 1521 */ 1522 #define elf_backend_create_dynamic_sections i370_elf_create_dynamic_sections 1523 #define elf_backend_size_dynamic_sections i370_elf_size_dynamic_sections 1524 #define elf_backend_finish_dynamic_sections i370_elf_finish_dynamic_sections 1525 #define elf_backend_fake_sections i370_elf_fake_sections 1526 #define elf_backend_section_from_shdr i370_elf_section_from_shdr 1527 #define elf_backend_adjust_dynamic_symbol i370_elf_adjust_dynamic_symbol 1528 #define elf_backend_check_relocs i370_elf_check_relocs 1529 1530 /* 1531 #define elf_backend_add_symbol_hook i370_elf_add_symbol_hook 1532 #define elf_backend_finish_dynamic_symbol i370_elf_finish_dynamic_symbol 1533 #define elf_backend_additional_program_headers i370_elf_additional_program_headers 1534 #define elf_backend_modify_segment_map i370_elf_modify_segment_map 1535 */ 1536 1537 #define elf_backend_post_process_headers i370_elf_post_process_headers 1538 1539 static int i370_noop 1540 PARAMS ((void)); 1541 1542 static int i370_noop () 1543 { 1544 return 1; 1545 } 1546 1547 /* we need to define these at least as no-ops to link glibc ld.so */ 1548 1549 #define elf_backend_add_symbol_hook \ 1550 (bfd_boolean (*) \ 1551 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Sym *, \ 1552 const char **, flagword *, asection **, bfd_vma *))) i370_noop 1553 #define elf_backend_finish_dynamic_symbol \ 1554 (bfd_boolean (*) \ 1555 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, \ 1556 Elf_Internal_Sym *))) i370_noop 1557 #define elf_backend_additional_program_headers \ 1558 (int (*) PARAMS ((bfd *))) i370_noop 1559 #define elf_backend_modify_segment_map \ 1560 (bfd_boolean (*) PARAMS ((bfd *, struct bfd_link_info *))) i370_noop 1561 1562 #include "elf32-target.h" 1563