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