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