1/* i370-specific support for 32-bit ELF 2 Copyright 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004, 3 2005, 2006, 2007 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 3 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 "sysdep.h" 31#include "bfd.h" 32#include "bfdlink.h" 33#include "libbfd.h" 34#include "elf-bfd.h" 35#include "elf/i370.h" 36 37static reloc_howto_type *i370_elf_howto_table[ (int)R_I370_max ]; 38 39static 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 231static void 232i370_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 244static reloc_howto_type * 245i370_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 270static reloc_howto_type * 271i370_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 293static void 294i370_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 310static bfd_boolean 311i370_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 324static bfd_boolean 325i370_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 359 is called when elfcode.h finds a section with an unknown type. */ 360/* XXX hack alert bogus This routine is mostly all junk and almost 361 certainly does the wrong thing. Its here simply because it does 362 just enough to allow glibc-2.1 ld.so to compile & link. */ 363 364static bfd_boolean 365i370_elf_section_from_shdr (bfd *abfd, 366 Elf_Internal_Shdr *hdr, 367 const char *name, 368 int shindex) 369{ 370 asection *newsect; 371 flagword flags; 372 373 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) 374 return FALSE; 375 376 newsect = hdr->bfd_section; 377 flags = bfd_get_section_flags (abfd, newsect); 378 if (hdr->sh_flags & SHF_EXCLUDE) 379 flags |= SEC_EXCLUDE; 380 381 if (hdr->sh_type == SHT_ORDERED) 382 flags |= SEC_SORT_ENTRIES; 383 384 bfd_set_section_flags (abfd, newsect, flags); 385 return TRUE; 386} 387 388/* Set up any other section flags and such that may be necessary. */ 389/* XXX hack alert bogus This routine is mostly all junk and almost 390 certainly does the wrong thing. Its here simply because it does 391 just enough to allow glibc-2.1 ld.so to compile & link. */ 392 393static bfd_boolean 394i370_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, 395 Elf_Internal_Shdr *shdr, 396 asection *asect) 397{ 398 if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE) 399 shdr->sh_flags |= SHF_EXCLUDE; 400 401 if ((asect->flags & SEC_SORT_ENTRIES) != 0) 402 shdr->sh_type = SHT_ORDERED; 403 404 return TRUE; 405} 406 407/* 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 414static bfd_boolean 415i370_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_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_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_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 458static bfd_boolean 459i370_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_section_by_name (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 if (h->size == 0) 505 { 506 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"), 507 h->root.root.string); 508 return TRUE; 509 } 510 511 /* We must allocate the symbol in our .dynbss section, which will 512 become part of the .bss section of the executable. There will be 513 an entry for this symbol in the .dynsym section. The dynamic 514 object will contain position independent code, so all references 515 from the dynamic object to this symbol will go through the global 516 offset table. The dynamic linker will use the .dynsym entry to 517 determine the address it must put in the global offset table, so 518 both the dynamic object and the regular object will refer to the 519 same memory location for the variable. 520 521 Of course, if the symbol is sufficiently small, we must instead 522 allocate it in .sbss. FIXME: It would be better to do this if and 523 only if there were actually SDAREL relocs for that symbol. */ 524 525 if (h->size <= elf_gp_size (dynobj)) 526 s = bfd_get_section_by_name (dynobj, ".dynsbss"); 527 else 528 s = bfd_get_section_by_name (dynobj, ".dynbss"); 529 BFD_ASSERT (s != NULL); 530 531 /* We must generate a R_I370_COPY reloc to tell the dynamic linker to 532 copy the initial value out of the dynamic object and into the 533 runtime process image. We need to remember the offset into the 534 .rela.bss section we are going to use. */ 535 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 536 { 537 asection *srel; 538 539 if (h->size <= elf_gp_size (dynobj)) 540 srel = bfd_get_section_by_name (dynobj, ".rela.sbss"); 541 else 542 srel = bfd_get_section_by_name (dynobj, ".rela.bss"); 543 BFD_ASSERT (srel != NULL); 544 srel->size += sizeof (Elf32_External_Rela); 545 h->needs_copy = 1; 546 } 547 548 return _bfd_elf_adjust_dynamic_copy (h, s); 549} 550 551/* Increment the index of a dynamic symbol by a given amount. Called 552 via elf_link_hash_traverse. */ 553/* XXX hack alert bogus This routine is mostly all junk and almost 554 certainly does the wrong thing. Its here simply because it does 555 just enough to allow glibc-2.1 ld.so to compile & link. */ 556 557static bfd_boolean 558i370_elf_adjust_dynindx (struct elf_link_hash_entry *h, void * cparg) 559{ 560 int *cp = (int *) cparg; 561 562#ifdef DEBUG 563 fprintf (stderr, 564 "i370_elf_adjust_dynindx called, h->dynindx = %ld, *cp = %d\n", 565 h->dynindx, *cp); 566#endif 567 568 if (h->root.type == bfd_link_hash_warning) 569 h = (struct elf_link_hash_entry *) h->root.u.i.link; 570 571 if (h->dynindx != -1) 572 h->dynindx += *cp; 573 574 return TRUE; 575} 576 577/* Set the sizes of the dynamic sections. */ 578/* XXX hack alert bogus This routine is mostly all junk and almost 579 certainly does the wrong thing. Its here simply because it does 580 just enough to allow glibc-2.1 ld.so to compile & link. */ 581 582static bfd_boolean 583i370_elf_size_dynamic_sections (bfd *output_bfd, 584 struct bfd_link_info *info) 585{ 586 bfd *dynobj; 587 asection *s; 588 bfd_boolean plt; 589 bfd_boolean relocs; 590 bfd_boolean reltext; 591 592#ifdef DEBUG 593 fprintf (stderr, "i370_elf_size_dynamic_sections called\n"); 594#endif 595 596 dynobj = elf_hash_table (info)->dynobj; 597 BFD_ASSERT (dynobj != NULL); 598 599 if (elf_hash_table (info)->dynamic_sections_created) 600 { 601 /* Set the contents of the .interp section to the interpreter. */ 602 if (info->executable) 603 { 604 s = bfd_get_section_by_name (dynobj, ".interp"); 605 BFD_ASSERT (s != NULL); 606 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 607 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 608 } 609 } 610 else 611 { 612 /* We may have created entries in the .rela.got, .rela.sdata, and 613 .rela.sdata2 sections. However, if we are not creating the 614 dynamic sections, we will not actually use these entries. Reset 615 the size of .rela.got, et al, which will cause it to get 616 stripped from the output file below. */ 617 static char *rela_sections[] = { ".rela.got", ".rela.sdata", 618 ".rela.sdata2", ".rela.sbss", 619 NULL }; 620 char **p; 621 622 for (p = rela_sections; *p != NULL; p++) 623 { 624 s = bfd_get_section_by_name (dynobj, *p); 625 if (s != NULL) 626 s->size = 0; 627 } 628 } 629 630 /* The check_relocs and adjust_dynamic_symbol entry points have 631 determined the sizes of the various dynamic sections. Allocate 632 memory for them. */ 633 plt = FALSE; 634 relocs = FALSE; 635 reltext = FALSE; 636 for (s = dynobj->sections; s != NULL; s = s->next) 637 { 638 const char *name; 639 640 if ((s->flags & SEC_LINKER_CREATED) == 0) 641 continue; 642 643 /* It's OK to base decisions on the section name, because none 644 of the dynobj section names depend upon the input files. */ 645 name = bfd_get_section_name (dynobj, s); 646 647 if (strcmp (name, ".plt") == 0) 648 { 649 /* Remember whether there is a PLT. */ 650 plt = s->size != 0; 651 } 652 else if (CONST_STRNEQ (name, ".rela")) 653 { 654 if (s->size != 0) 655 { 656 asection *target; 657 const char *outname; 658 659 /* Remember whether there are any relocation sections. */ 660 relocs = TRUE; 661 662 /* If this relocation section applies to a read only 663 section, then we probably need a DT_TEXTREL entry. */ 664 outname = bfd_get_section_name (output_bfd, 665 s->output_section); 666 target = bfd_get_section_by_name (output_bfd, outname + 5); 667 if (target != NULL 668 && (target->flags & SEC_READONLY) != 0 669 && (target->flags & SEC_ALLOC) != 0) 670 reltext = TRUE; 671 672 /* We use the reloc_count field as a counter if we need 673 to copy relocs into the output file. */ 674 s->reloc_count = 0; 675 } 676 } 677 else if (strcmp (name, ".got") != 0 678 && strcmp (name, ".sdata") != 0 679 && strcmp (name, ".sdata2") != 0 680 && strcmp (name, ".dynbss") != 0 681 && strcmp (name, ".dynsbss") != 0) 682 { 683 /* It's not one of our sections, so don't allocate space. */ 684 continue; 685 } 686 687 if (s->size == 0) 688 { 689 /* If we don't need this section, strip it from the 690 output file. This is mostly to handle .rela.bss and 691 .rela.plt. We must create both sections in 692 create_dynamic_sections, because they must be created 693 before the linker maps input sections to output 694 sections. The linker does that before 695 adjust_dynamic_symbol is called, and it is that 696 function which decides whether anything needs to go 697 into these sections. */ 698 s->flags |= SEC_EXCLUDE; 699 continue; 700 } 701 702 if ((s->flags & SEC_HAS_CONTENTS) == 0) 703 continue; 704 705 /* Allocate memory for the section contents. */ 706 s->contents = bfd_zalloc (dynobj, s->size); 707 if (s->contents == NULL) 708 return FALSE; 709 } 710 711 if (elf_hash_table (info)->dynamic_sections_created) 712 { 713 /* Add some entries to the .dynamic section. We fill in the 714 values later, in i370_elf_finish_dynamic_sections, but we 715 must add the entries now so that we get the correct size for 716 the .dynamic section. The DT_DEBUG entry is filled in by the 717 dynamic linker and used by the debugger. */ 718#define add_dynamic_entry(TAG, VAL) \ 719 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 720 721 if (!info->shared) 722 { 723 if (!add_dynamic_entry (DT_DEBUG, 0)) 724 return FALSE; 725 } 726 727 if (plt) 728 { 729 if (!add_dynamic_entry (DT_PLTGOT, 0) 730 || !add_dynamic_entry (DT_PLTRELSZ, 0) 731 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 732 || !add_dynamic_entry (DT_JMPREL, 0)) 733 return FALSE; 734 } 735 736 if (relocs) 737 { 738 if (!add_dynamic_entry (DT_RELA, 0) 739 || !add_dynamic_entry (DT_RELASZ, 0) 740 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))) 741 return FALSE; 742 } 743 744 if (reltext) 745 { 746 if (!add_dynamic_entry (DT_TEXTREL, 0)) 747 return FALSE; 748 info->flags |= DF_TEXTREL; 749 } 750 } 751#undef add_dynamic_entry 752 753 /* If we are generating a shared library, we generate a section 754 symbol for each output section. These are local symbols, which 755 means that they must come first in the dynamic symbol table. 756 That means we must increment the dynamic symbol index of every 757 other dynamic symbol. 758 759 FIXME: We assume that there will never be relocations to 760 locations in linker-created sections that do not have 761 externally-visible names. Instead, we should work out precisely 762 which sections relocations are targeted at. */ 763 if (info->shared) 764 { 765 int c; 766 767 for (c = 0, s = output_bfd->sections; s != NULL; s = s->next) 768 { 769 if ((s->flags & SEC_LINKER_CREATED) != 0 770 || (s->flags & SEC_ALLOC) == 0) 771 { 772 elf_section_data (s)->dynindx = -1; 773 continue; 774 } 775 776 /* These symbols will have no names, so we don't need to 777 fiddle with dynstr_index. */ 778 779 elf_section_data (s)->dynindx = c + 1; 780 781 c++; 782 } 783 784 elf_link_hash_traverse (elf_hash_table (info), 785 i370_elf_adjust_dynindx, & c); 786 elf_hash_table (info)->dynsymcount += c; 787 } 788 789 return TRUE; 790} 791 792/* Look through the relocs for a section during the first phase, and 793 allocate space in the global offset table or procedure linkage 794 table. */ 795/* XXX hack alert bogus This routine is mostly all junk and almost 796 certainly does the wrong thing. Its here simply because it does 797 just enough to allow glibc-2.1 ld.so to compile & link. */ 798 799static bfd_boolean 800i370_elf_check_relocs (bfd *abfd, 801 struct bfd_link_info *info, 802 asection *sec, 803 const Elf_Internal_Rela *relocs) 804{ 805 bfd *dynobj; 806 Elf_Internal_Shdr *symtab_hdr; 807 struct elf_link_hash_entry **sym_hashes; 808 const Elf_Internal_Rela *rel; 809 const Elf_Internal_Rela *rel_end; 810 bfd_vma *local_got_offsets; 811 asection *sreloc; 812 813 if (info->relocatable) 814 return TRUE; 815 816#ifdef DEBUG 817 _bfd_error_handler ("i370_elf_check_relocs called for section %A in %B", 818 sec, abfd); 819#endif 820 821 dynobj = elf_hash_table (info)->dynobj; 822 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 823 sym_hashes = elf_sym_hashes (abfd); 824 local_got_offsets = elf_local_got_offsets (abfd); 825 826 sreloc = NULL; 827 828 rel_end = relocs + sec->reloc_count; 829 for (rel = relocs; rel < rel_end; rel++) 830 { 831 unsigned long r_symndx; 832 struct elf_link_hash_entry *h; 833 834 r_symndx = ELF32_R_SYM (rel->r_info); 835 if (r_symndx < symtab_hdr->sh_info) 836 h = NULL; 837 else 838 { 839 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 840 while (h->root.type == bfd_link_hash_indirect 841 || h->root.type == bfd_link_hash_warning) 842 h = (struct elf_link_hash_entry *) h->root.u.i.link; 843 } 844 845 if (info->shared) 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 const char *name; 856 857 name = (bfd_elf_string_from_elf_section 858 (abfd, 859 elf_elfheader (abfd)->e_shstrndx, 860 elf_section_data (sec)->rel_hdr.sh_name)); 861 if (name == NULL) 862 return FALSE; 863 864 BFD_ASSERT (CONST_STRNEQ (name, ".rela") 865 && strcmp (bfd_get_section_name (abfd, sec), name + 5) == 0); 866 867 sreloc = bfd_get_section_by_name (dynobj, name); 868 if (sreloc == NULL) 869 { 870 flagword flags; 871 872 flags = (SEC_HAS_CONTENTS | SEC_READONLY 873 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 874 if ((sec->flags & SEC_ALLOC) != 0) 875 flags |= SEC_ALLOC | SEC_LOAD; 876 sreloc = bfd_make_section_with_flags (dynobj, name, 877 flags); 878 if (sreloc == NULL 879 || ! bfd_set_section_alignment (dynobj, sreloc, 2)) 880 return FALSE; 881 } 882 } 883 884 sreloc->size += sizeof (Elf32_External_Rela); 885 886 /* FIXME: We should here do what the m68k and i386 887 backends do: if the reloc is pc-relative, record it 888 in case it turns out that the reloc is unnecessary 889 because the symbol is forced local by versioning or 890 we are linking with -Bdynamic. Fortunately this 891 case is not frequent. */ 892 } 893 } 894 895 return TRUE; 896} 897 898/* Finish up the dynamic sections. */ 899/* XXX hack alert bogus This routine is mostly all junk and almost 900 certainly does the wrong thing. Its here simply because it does 901 just enough to allow glibc-2.1 ld.so to compile & link. */ 902 903static bfd_boolean 904i370_elf_finish_dynamic_sections (bfd *output_bfd, 905 struct bfd_link_info *info) 906{ 907 asection *sdyn; 908 bfd *dynobj = elf_hash_table (info)->dynobj; 909 asection *sgot = bfd_get_section_by_name (dynobj, ".got"); 910 911#ifdef DEBUG 912 fprintf (stderr, "i370_elf_finish_dynamic_sections called\n"); 913#endif 914 915 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 916 917 if (elf_hash_table (info)->dynamic_sections_created) 918 { 919 asection *splt; 920 Elf32_External_Dyn *dyncon, *dynconend; 921 922 splt = bfd_get_section_by_name (dynobj, ".plt"); 923 BFD_ASSERT (splt != NULL && sdyn != NULL); 924 925 dyncon = (Elf32_External_Dyn *) sdyn->contents; 926 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 927 for (; dyncon < dynconend; dyncon++) 928 { 929 Elf_Internal_Dyn dyn; 930 const char *name; 931 bfd_boolean size; 932 933 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 934 935 switch (dyn.d_tag) 936 { 937 case DT_PLTGOT: name = ".plt"; size = FALSE; break; 938 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break; 939 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break; 940 default: name = NULL; size = FALSE; break; 941 } 942 943 if (name != NULL) 944 { 945 asection *s; 946 947 s = bfd_get_section_by_name (output_bfd, name); 948 if (s == NULL) 949 dyn.d_un.d_val = 0; 950 else 951 { 952 if (! size) 953 dyn.d_un.d_ptr = s->vma; 954 else 955 dyn.d_un.d_val = s->size; 956 } 957 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 958 } 959 } 960 } 961 962 if (sgot && sgot->size != 0) 963 { 964 unsigned char *contents = sgot->contents; 965 966 if (sdyn == NULL) 967 bfd_put_32 (output_bfd, (bfd_vma) 0, contents); 968 else 969 bfd_put_32 (output_bfd, 970 sdyn->output_section->vma + sdyn->output_offset, 971 contents); 972 973 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 974 } 975 976 if (info->shared) 977 { 978 asection *sdynsym; 979 asection *s; 980 Elf_Internal_Sym sym; 981 int maxdindx = 0; 982 983 /* Set up the section symbols for the output sections. */ 984 985 sdynsym = bfd_get_section_by_name (dynobj, ".dynsym"); 986 BFD_ASSERT (sdynsym != NULL); 987 988 sym.st_size = 0; 989 sym.st_name = 0; 990 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION); 991 sym.st_other = 0; 992 993 for (s = output_bfd->sections; s != NULL; s = s->next) 994 { 995 int indx, dindx; 996 Elf32_External_Sym *esym; 997 998 sym.st_value = s->vma; 999 1000 indx = elf_section_data (s)->this_idx; 1001 dindx = elf_section_data (s)->dynindx; 1002 if (dindx != -1) 1003 { 1004 BFD_ASSERT(indx > 0); 1005 BFD_ASSERT(dindx > 0); 1006 1007 if (dindx > maxdindx) 1008 maxdindx = dindx; 1009 1010 sym.st_shndx = indx; 1011 1012 esym = (Elf32_External_Sym *) sdynsym->contents + dindx; 1013 bfd_elf32_swap_symbol_out (output_bfd, &sym, esym, NULL); 1014 } 1015 } 1016 1017 /* Set the sh_info field of the output .dynsym section to the 1018 index of the first global symbol. */ 1019 elf_section_data (sdynsym->output_section)->this_hdr.sh_info = 1020 maxdindx + 1; 1021 } 1022 1023 return TRUE; 1024} 1025 1026/* The RELOCATE_SECTION function is called by the ELF backend linker 1027 to handle the relocations for a section. 1028 1029 The relocs are always passed as Rela structures; if the section 1030 actually uses Rel structures, the r_addend field will always be 1031 zero. 1032 1033 This function is responsible for adjust the section contents as 1034 necessary, and (if using Rela relocs and generating a 1035 relocatable output file) adjusting the reloc addend as 1036 necessary. 1037 1038 This function does not have to worry about setting the reloc 1039 address or the reloc symbol index. 1040 1041 LOCAL_SYMS is a pointer to the swapped in local symbols. 1042 1043 LOCAL_SECTIONS is an array giving the section in the input file 1044 corresponding to the st_shndx field of each local symbol. 1045 1046 The global hash table entry for the global symbols can be found 1047 via elf_sym_hashes (input_bfd). 1048 1049 When generating relocatable output, this function must handle 1050 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 1051 going to be the section symbol corresponding to the output 1052 section, which means that the addend must be adjusted 1053 accordingly. */ 1054 1055static bfd_boolean 1056i370_elf_relocate_section (bfd *output_bfd, 1057 struct bfd_link_info *info, 1058 bfd *input_bfd, 1059 asection *input_section, 1060 bfd_byte *contents, 1061 Elf_Internal_Rela *relocs, 1062 Elf_Internal_Sym *local_syms, 1063 asection **local_sections) 1064{ 1065 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1066 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd); 1067 bfd *dynobj = elf_hash_table (info)->dynobj; 1068 Elf_Internal_Rela *rel = relocs; 1069 Elf_Internal_Rela *relend = relocs + input_section->reloc_count; 1070 asection *sreloc = NULL; 1071 bfd_vma *local_got_offsets; 1072 bfd_boolean ret = TRUE; 1073 1074#ifdef DEBUG 1075 _bfd_error_handler ("i370_elf_relocate_section called for %B section %A, %ld relocations%s", 1076 input_bfd, input_section, 1077 (long) input_section->reloc_count, 1078 (info->relocatable) ? " (relocatable)" : ""); 1079#endif 1080 1081 if (!i370_elf_howto_table[ R_I370_ADDR31 ]) 1082 /* Initialize howto table if needed. */ 1083 i370_elf_howto_init (); 1084 1085 local_got_offsets = elf_local_got_offsets (input_bfd); 1086 1087 for (; rel < relend; rel++) 1088 { 1089 enum i370_reloc_type r_type = (enum i370_reloc_type) ELF32_R_TYPE (rel->r_info); 1090 bfd_vma offset = rel->r_offset; 1091 bfd_vma addend = rel->r_addend; 1092 bfd_reloc_status_type r = bfd_reloc_other; 1093 Elf_Internal_Sym *sym = NULL; 1094 asection *sec = NULL; 1095 struct elf_link_hash_entry * h = NULL; 1096 const char *sym_name = NULL; 1097 reloc_howto_type *howto; 1098 unsigned long r_symndx; 1099 bfd_vma relocation; 1100 1101 /* Unknown relocation handling. */ 1102 if ((unsigned) r_type >= (unsigned) R_I370_max 1103 || !i370_elf_howto_table[(int)r_type]) 1104 { 1105 (*_bfd_error_handler) ("%B: unknown relocation type %d", 1106 input_bfd, 1107 (int) r_type); 1108 1109 bfd_set_error (bfd_error_bad_value); 1110 ret = FALSE; 1111 continue; 1112 } 1113 1114 howto = i370_elf_howto_table[(int) r_type]; 1115 r_symndx = ELF32_R_SYM (rel->r_info); 1116 relocation = 0; 1117 1118 if (r_symndx < symtab_hdr->sh_info) 1119 { 1120 sym = local_syms + r_symndx; 1121 sec = local_sections[r_symndx]; 1122 sym_name = "<local symbol>"; 1123 1124 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel); 1125 addend = rel->r_addend; 1126 } 1127 else 1128 { 1129 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1130 while (h->root.type == bfd_link_hash_indirect 1131 || h->root.type == bfd_link_hash_warning) 1132 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1133 sym_name = h->root.root.string; 1134 if (h->root.type == bfd_link_hash_defined 1135 || h->root.type == bfd_link_hash_defweak) 1136 { 1137 sec = h->root.u.def.section; 1138 if (info->shared 1139 && ((! info->symbolic && h->dynindx != -1) 1140 || !h->def_regular) 1141 && (input_section->flags & SEC_ALLOC) != 0 1142 && (r_type == R_I370_ADDR31 1143 || r_type == R_I370_COPY 1144 || r_type == R_I370_ADDR16 1145 || r_type == R_I370_RELATIVE)) 1146 /* In these cases, we don't need the relocation 1147 value. We check specially because in some 1148 obscure cases sec->output_section will be NULL. */ 1149 ; 1150 else 1151 relocation = (h->root.u.def.value 1152 + sec->output_section->vma 1153 + sec->output_offset); 1154 } 1155 else if (h->root.type == bfd_link_hash_undefweak) 1156 ; 1157 else if (info->unresolved_syms_in_objects == RM_IGNORE 1158 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 1159 ; 1160 else if (!info->relocatable) 1161 { 1162 if ((*info->callbacks->undefined_symbol) 1163 (info, h->root.root.string, input_bfd, 1164 input_section, rel->r_offset, 1165 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR 1166 || ELF_ST_VISIBILITY (h->other)))) 1167 { 1168 ret = FALSE; 1169 continue; 1170 } 1171 } 1172 } 1173 1174 if (sec != NULL && elf_discarded_section (sec)) 1175 { 1176 /* For relocs against symbols from removed linkonce sections, 1177 or sections discarded by a linker script, we just want the 1178 section contents zeroed. Avoid any special processing. */ 1179 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset); 1180 rel->r_info = 0; 1181 rel->r_addend = 0; 1182 continue; 1183 } 1184 1185 if (info->relocatable) 1186 continue; 1187 1188 switch ((int) r_type) 1189 { 1190 default: 1191 (*_bfd_error_handler) 1192 ("%B: unknown relocation type %d for symbol %s", 1193 input_bfd, (int) r_type, sym_name); 1194 1195 bfd_set_error (bfd_error_bad_value); 1196 ret = FALSE; 1197 continue; 1198 1199 case (int) R_I370_NONE: 1200 continue; 1201 1202 /* Relocations that may need to be propagated if this is a shared 1203 object. */ 1204 case (int) R_I370_REL31: 1205 /* If these relocations are not to a named symbol, they can be 1206 handled right here, no need to bother the dynamic linker. */ 1207 if (h == NULL 1208 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 1209 break; 1210 /* Fall through. */ 1211 1212 /* Relocations that always need to be propagated if this is a shared 1213 object. */ 1214 case (int) R_I370_ADDR31: 1215 case (int) R_I370_ADDR16: 1216 if (info->shared 1217 && r_symndx != 0) 1218 { 1219 Elf_Internal_Rela outrel; 1220 bfd_byte *loc; 1221 int skip; 1222 1223#ifdef DEBUG 1224 fprintf (stderr, 1225 "i370_elf_relocate_section needs to create relocation for %s\n", 1226 (h && h->root.root.string) ? h->root.root.string : "<unknown>"); 1227#endif 1228 1229 /* When generating a shared object, these relocations 1230 are copied into the output file to be resolved at run 1231 time. */ 1232 1233 if (sreloc == NULL) 1234 { 1235 const char *name; 1236 1237 name = (bfd_elf_string_from_elf_section 1238 (input_bfd, 1239 elf_elfheader (input_bfd)->e_shstrndx, 1240 elf_section_data (input_section)->rel_hdr.sh_name)); 1241 if (name == NULL) 1242 return FALSE; 1243 1244 BFD_ASSERT (CONST_STRNEQ (name, ".rela") 1245 && strcmp (bfd_get_section_name (input_bfd, 1246 input_section), 1247 name + 5) == 0); 1248 1249 sreloc = bfd_get_section_by_name (dynobj, name); 1250 BFD_ASSERT (sreloc != NULL); 1251 } 1252 1253 skip = 0; 1254 1255 outrel.r_offset = 1256 _bfd_elf_section_offset (output_bfd, info, input_section, 1257 rel->r_offset); 1258 if (outrel.r_offset == (bfd_vma) -1 1259 || outrel.r_offset == (bfd_vma) -2) 1260 skip = (int) outrel.r_offset; 1261 outrel.r_offset += (input_section->output_section->vma 1262 + input_section->output_offset); 1263 1264 if (skip) 1265 memset (&outrel, 0, sizeof outrel); 1266 /* h->dynindx may be -1 if this symbol was marked to 1267 become local. */ 1268 else if (h != NULL 1269 && ((! info->symbolic && h->dynindx != -1) 1270 || !h->def_regular)) 1271 { 1272 BFD_ASSERT (h->dynindx != -1); 1273 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 1274 outrel.r_addend = rel->r_addend; 1275 } 1276 else 1277 { 1278 if (r_type == R_I370_ADDR31) 1279 { 1280 outrel.r_info = ELF32_R_INFO (0, R_I370_RELATIVE); 1281 outrel.r_addend = relocation + rel->r_addend; 1282 } 1283 else 1284 { 1285 long indx; 1286 1287 if (bfd_is_abs_section (sec)) 1288 indx = 0; 1289 else if (sec == NULL || sec->owner == NULL) 1290 { 1291 bfd_set_error (bfd_error_bad_value); 1292 return FALSE; 1293 } 1294 else 1295 { 1296 asection *osec; 1297 1298 /* We are turning this relocation into one 1299 against a section symbol. It would be 1300 proper to subtract the symbol's value, 1301 osec->vma, from the emitted reloc addend, 1302 but ld.so expects buggy relocs. */ 1303 osec = sec->output_section; 1304 indx = elf_section_data (osec)->dynindx; 1305 if (indx == 0) 1306 { 1307 struct elf_link_hash_table *htab; 1308 htab = elf_hash_table (info); 1309 osec = htab->text_index_section; 1310 indx = elf_section_data (osec)->dynindx; 1311 } 1312 BFD_ASSERT (indx != 0); 1313#ifdef DEBUG 1314 if (indx <= 0) 1315 { 1316 printf ("indx=%ld section=%s flags=%08x name=%s\n", 1317 indx, osec->name, osec->flags, 1318 h->root.root.string); 1319 } 1320#endif 1321 } 1322 1323 outrel.r_info = ELF32_R_INFO (indx, r_type); 1324 outrel.r_addend = relocation + rel->r_addend; 1325 } 1326 } 1327 1328 loc = sreloc->contents; 1329 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela); 1330 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 1331 1332 /* This reloc will be computed at runtime, so there's no 1333 need to do anything now, unless this is a RELATIVE 1334 reloc in an unallocated section. */ 1335 if (skip == -1 1336 || (input_section->flags & SEC_ALLOC) != 0 1337 || ELF32_R_TYPE (outrel.r_info) != R_I370_RELATIVE) 1338 continue; 1339 } 1340 break; 1341 1342 case (int) R_I370_COPY: 1343 case (int) R_I370_RELATIVE: 1344 (*_bfd_error_handler) 1345 ("%B: Relocation %s is not yet supported for symbol %s.", 1346 input_bfd, 1347 i370_elf_howto_table[(int) r_type]->name, 1348 sym_name); 1349 1350 bfd_set_error (bfd_error_invalid_operation); 1351 ret = FALSE; 1352 continue; 1353 } 1354 1355#ifdef DEBUG 1356 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n", 1357 howto->name, 1358 (int)r_type, 1359 sym_name, 1360 r_symndx, 1361 (long) offset, 1362 (long) addend); 1363#endif 1364 1365 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents, 1366 offset, relocation, addend); 1367 1368 if (r != bfd_reloc_ok) 1369 { 1370 ret = FALSE; 1371 switch (r) 1372 { 1373 default: 1374 break; 1375 1376 case bfd_reloc_overflow: 1377 { 1378 const char *name; 1379 1380 if (h != NULL) 1381 name = NULL; 1382 else 1383 { 1384 name = bfd_elf_string_from_elf_section (input_bfd, 1385 symtab_hdr->sh_link, 1386 sym->st_name); 1387 if (name == NULL) 1388 break; 1389 1390 if (*name == '\0') 1391 name = bfd_section_name (input_bfd, sec); 1392 } 1393 1394 (*info->callbacks->reloc_overflow) (info, 1395 (h ? &h->root : NULL), 1396 name, 1397 howto->name, 1398 (bfd_vma) 0, 1399 input_bfd, 1400 input_section, 1401 offset); 1402 } 1403 break; 1404 } 1405 } 1406 } 1407 1408#ifdef DEBUG 1409 fprintf (stderr, "\n"); 1410#endif 1411 1412 return ret; 1413} 1414 1415#define TARGET_BIG_SYM bfd_elf32_i370_vec 1416#define TARGET_BIG_NAME "elf32-i370" 1417#define ELF_ARCH bfd_arch_i370 1418#define ELF_MACHINE_CODE EM_S370 1419#ifdef EM_I370_OLD 1420#define ELF_MACHINE_ALT1 EM_I370_OLD 1421#endif 1422#define ELF_MAXPAGESIZE 0x1000 1423#define ELF_OSABI ELFOSABI_LINUX 1424 1425#define elf_info_to_howto i370_elf_info_to_howto 1426 1427#define elf_backend_plt_not_loaded 1 1428#define elf_backend_rela_normal 1 1429 1430#define bfd_elf32_bfd_reloc_type_lookup i370_elf_reloc_type_lookup 1431#define bfd_elf32_bfd_reloc_name_lookup i370_elf_reloc_name_lookup 1432#define bfd_elf32_bfd_set_private_flags i370_elf_set_private_flags 1433#define bfd_elf32_bfd_merge_private_bfd_data i370_elf_merge_private_bfd_data 1434#define elf_backend_relocate_section i370_elf_relocate_section 1435 1436/* Dynamic loader support is mostly broken; just enough here to be able to 1437 link glibc's ld.so without errors. */ 1438#define elf_backend_create_dynamic_sections i370_elf_create_dynamic_sections 1439#define elf_backend_size_dynamic_sections i370_elf_size_dynamic_sections 1440#define elf_backend_init_index_section _bfd_elf_init_1_index_section 1441#define elf_backend_finish_dynamic_sections i370_elf_finish_dynamic_sections 1442#define elf_backend_fake_sections i370_elf_fake_sections 1443#define elf_backend_section_from_shdr i370_elf_section_from_shdr 1444#define elf_backend_adjust_dynamic_symbol i370_elf_adjust_dynamic_symbol 1445#define elf_backend_check_relocs i370_elf_check_relocs 1446#define elf_backend_post_process_headers _bfd_elf_set_osabi 1447 1448static int 1449i370_noop (void) 1450{ 1451 return 1; 1452} 1453 1454#define elf_backend_finish_dynamic_symbol \ 1455 (bfd_boolean (*) \ 1456 (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, \ 1457 Elf_Internal_Sym *)) i370_noop 1458 1459#include "elf32-target.h" 1460