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