elf32-i386.c revision 57406
1/* Intel 80386/80486-specific support for 32-bit ELF 2 Copyright 1993-1997, 1998 Free Software Foundation, Inc. 3 4This file is part of BFD, the Binary File Descriptor library. 5 6This program is free software; you can redistribute it and/or modify 7it under the terms of the GNU General Public License as published by 8the Free Software Foundation; either version 2 of the License, or 9(at your option) any later version. 10 11This program is distributed in the hope that it will be useful, 12but WITHOUT ANY WARRANTY; without even the implied warranty of 13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14GNU General Public License for more details. 15 16You should have received a copy of the GNU General Public License 17along with this program; if not, write to the Free Software 18Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 19 20/* $FreeBSD: head/contrib/binutils/bfd/elf32-i386.c 57406 2000-02-24 05:46:27Z jdp $ */ 21 22#include "bfd.h" 23#include "sysdep.h" 24#include "bfdlink.h" 25#include "libbfd.h" 26#include "elf-bfd.h" 27 28static reloc_howto_type *elf_i386_reloc_type_lookup 29 PARAMS ((bfd *, bfd_reloc_code_real_type)); 30static void elf_i386_info_to_howto 31 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *)); 32static void elf_i386_info_to_howto_rel 33 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *)); 34static boolean elf_i386_is_local_label_name PARAMS ((bfd *, const char *)); 35static struct bfd_hash_entry *elf_i386_link_hash_newfunc 36 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); 37static struct bfd_link_hash_table *elf_i386_link_hash_table_create 38 PARAMS ((bfd *)); 39static boolean elf_i386_check_relocs 40 PARAMS ((bfd *, struct bfd_link_info *, asection *, 41 const Elf_Internal_Rela *)); 42static boolean elf_i386_adjust_dynamic_symbol 43 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); 44static boolean elf_i386_size_dynamic_sections 45 PARAMS ((bfd *, struct bfd_link_info *)); 46static boolean elf_i386_relocate_section 47 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 48 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); 49static boolean elf_i386_finish_dynamic_symbol 50 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, 51 Elf_Internal_Sym *)); 52static boolean elf_i386_finish_dynamic_sections 53 PARAMS ((bfd *, struct bfd_link_info *)); 54 55#define USE_REL 1 /* 386 uses REL relocations instead of RELA */ 56 57enum reloc_type 58 { 59 R_386_NONE = 0, 60 R_386_32, 61 R_386_PC32, 62 R_386_GOT32, 63 R_386_PLT32, 64 R_386_COPY, 65 R_386_GLOB_DAT, 66 R_386_JUMP_SLOT, 67 R_386_RELATIVE, 68 R_386_GOTOFF, 69 R_386_GOTPC, 70 FIRST_INVALID_RELOC, 71 LAST_INVALID_RELOC = 19, 72 /* The remaining relocs are a GNU extension. */ 73 R_386_16 = 20, 74 R_386_PC16, 75 R_386_8, 76 R_386_PC8, 77 R_386_max 78 }; 79 80#if 0 81static CONST char *CONST reloc_type_names[] = 82{ 83 "R_386_NONE", 84 "R_386_32", 85 "R_386_PC32", 86 "R_386_GOT32", 87 "R_386_PLT32", 88 "R_386_COPY", 89 "R_386_GLOB_DAT", 90 "R_386_JUMP_SLOT", 91 "R_386_RELATIVE", 92 "R_386_GOTOFF", 93 "R_386_GOTPC", 94}; 95#endif 96 97static reloc_howto_type elf_howto_table[]= 98{ 99 HOWTO(R_386_NONE, 0,0, 0,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_NONE", true,0x00000000,0x00000000,false), 100 HOWTO(R_386_32, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_32", true,0xffffffff,0xffffffff,false), 101 HOWTO(R_386_PC32, 0,2,32,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC32", true,0xffffffff,0xffffffff,true), 102 HOWTO(R_386_GOT32, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOT32", true,0xffffffff,0xffffffff,false), 103 HOWTO(R_386_PLT32, 0,2,32,true,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PLT32", true,0xffffffff,0xffffffff,true), 104 HOWTO(R_386_COPY, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_COPY", true,0xffffffff,0xffffffff,false), 105 HOWTO(R_386_GLOB_DAT, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GLOB_DAT", true,0xffffffff,0xffffffff,false), 106 HOWTO(R_386_JUMP_SLOT, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_JUMP_SLOT",true,0xffffffff,0xffffffff,false), 107 HOWTO(R_386_RELATIVE, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_RELATIVE", true,0xffffffff,0xffffffff,false), 108 HOWTO(R_386_GOTOFF, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOTOFF", true,0xffffffff,0xffffffff,false), 109 HOWTO(R_386_GOTPC, 0,2,32,true,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOTPC", true,0xffffffff,0xffffffff,true), 110 { 11 }, 111 { 12 }, 112 { 13 }, 113 { 14 }, 114 { 15 }, 115 { 16 }, 116 { 17 }, 117 { 18 }, 118 { 19 }, 119 /* The remaining relocs are a GNU extension. */ 120 HOWTO(R_386_16, 0,1,16,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_16", true,0xffff,0xffff,false), 121 HOWTO(R_386_PC16, 0,1,16,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC16", true,0xffff,0xffff,true), 122 HOWTO(R_386_8, 0,0,8,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_8", true,0xff,0xff,false), 123 HOWTO(R_386_PC8, 0,0,8,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC8", true,0xff,0xff,true), 124}; 125 126#ifdef DEBUG_GEN_RELOC 127#define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str) 128#else 129#define TRACE(str) 130#endif 131 132static reloc_howto_type * 133elf_i386_reloc_type_lookup (abfd, code) 134 bfd *abfd; 135 bfd_reloc_code_real_type code; 136{ 137 switch (code) 138 { 139 case BFD_RELOC_NONE: 140 TRACE ("BFD_RELOC_NONE"); 141 return &elf_howto_table[ (int)R_386_NONE ]; 142 143 case BFD_RELOC_32: 144 TRACE ("BFD_RELOC_32"); 145 return &elf_howto_table[ (int)R_386_32 ]; 146 147 case BFD_RELOC_32_PCREL: 148 TRACE ("BFD_RELOC_PC32"); 149 return &elf_howto_table[ (int)R_386_PC32 ]; 150 151 case BFD_RELOC_386_GOT32: 152 TRACE ("BFD_RELOC_386_GOT32"); 153 return &elf_howto_table[ (int)R_386_GOT32 ]; 154 155 case BFD_RELOC_386_PLT32: 156 TRACE ("BFD_RELOC_386_PLT32"); 157 return &elf_howto_table[ (int)R_386_PLT32 ]; 158 159 case BFD_RELOC_386_COPY: 160 TRACE ("BFD_RELOC_386_COPY"); 161 return &elf_howto_table[ (int)R_386_COPY ]; 162 163 case BFD_RELOC_386_GLOB_DAT: 164 TRACE ("BFD_RELOC_386_GLOB_DAT"); 165 return &elf_howto_table[ (int)R_386_GLOB_DAT ]; 166 167 case BFD_RELOC_386_JUMP_SLOT: 168 TRACE ("BFD_RELOC_386_JUMP_SLOT"); 169 return &elf_howto_table[ (int)R_386_JUMP_SLOT ]; 170 171 case BFD_RELOC_386_RELATIVE: 172 TRACE ("BFD_RELOC_386_RELATIVE"); 173 return &elf_howto_table[ (int)R_386_RELATIVE ]; 174 175 case BFD_RELOC_386_GOTOFF: 176 TRACE ("BFD_RELOC_386_GOTOFF"); 177 return &elf_howto_table[ (int)R_386_GOTOFF ]; 178 179 case BFD_RELOC_386_GOTPC: 180 TRACE ("BFD_RELOC_386_GOTPC"); 181 return &elf_howto_table[ (int)R_386_GOTPC ]; 182 183 /* The remaining relocs are a GNU extension. */ 184 case BFD_RELOC_16: 185 TRACE ("BFD_RELOC_16"); 186 return &elf_howto_table[(int) R_386_16]; 187 188 case BFD_RELOC_16_PCREL: 189 TRACE ("BFD_RELOC_16_PCREL"); 190 return &elf_howto_table[(int) R_386_PC16]; 191 192 case BFD_RELOC_8: 193 TRACE ("BFD_RELOC_8"); 194 return &elf_howto_table[(int) R_386_8]; 195 196 case BFD_RELOC_8_PCREL: 197 TRACE ("BFD_RELOC_8_PCREL"); 198 return &elf_howto_table[(int) R_386_PC8]; 199 200 default: 201 break; 202 } 203 204 TRACE ("Unknown"); 205 return 0; 206} 207 208static void 209elf_i386_info_to_howto (abfd, cache_ptr, dst) 210 bfd *abfd; 211 arelent *cache_ptr; 212 Elf32_Internal_Rela *dst; 213{ 214 abort (); 215} 216 217static void 218elf_i386_info_to_howto_rel (abfd, cache_ptr, dst) 219 bfd *abfd; 220 arelent *cache_ptr; 221 Elf32_Internal_Rel *dst; 222{ 223 enum reloc_type type; 224 225 type = (enum reloc_type) ELF32_R_TYPE (dst->r_info); 226 BFD_ASSERT (type < R_386_max); 227 BFD_ASSERT (type < FIRST_INVALID_RELOC || type > LAST_INVALID_RELOC); 228 229 cache_ptr->howto = &elf_howto_table[(int) type]; 230} 231 232/* Return whether a symbol name implies a local label. The UnixWare 233 2.1 cc generates temporary symbols that start with .X, so we 234 recognize them here. FIXME: do other SVR4 compilers also use .X?. 235 If so, we should move the .X recognition into 236 _bfd_elf_is_local_label_name. */ 237 238static boolean 239elf_i386_is_local_label_name (abfd, name) 240 bfd *abfd; 241 const char *name; 242{ 243 if (name[0] == '.' && name[1] == 'X') 244 return true; 245 246 return _bfd_elf_is_local_label_name (abfd, name); 247} 248 249/* Functions for the i386 ELF linker. */ 250 251/* The name of the dynamic interpreter. This is put in the .interp 252 section. */ 253 254#define ELF_DYNAMIC_INTERPRETER "/usr/libexec/ld-elf.so.1" 255 256/* The size in bytes of an entry in the procedure linkage table. */ 257 258#define PLT_ENTRY_SIZE 16 259 260/* The first entry in an absolute procedure linkage table looks like 261 this. See the SVR4 ABI i386 supplement to see how this works. */ 262 263static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] = 264{ 265 0xff, 0x35, /* pushl contents of address */ 266 0, 0, 0, 0, /* replaced with address of .got + 4. */ 267 0xff, 0x25, /* jmp indirect */ 268 0, 0, 0, 0, /* replaced with address of .got + 8. */ 269 0, 0, 0, 0 /* pad out to 16 bytes. */ 270}; 271 272/* Subsequent entries in an absolute procedure linkage table look like 273 this. */ 274 275static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] = 276{ 277 0xff, 0x25, /* jmp indirect */ 278 0, 0, 0, 0, /* replaced with address of this symbol in .got. */ 279 0x68, /* pushl immediate */ 280 0, 0, 0, 0, /* replaced with offset into relocation table. */ 281 0xe9, /* jmp relative */ 282 0, 0, 0, 0 /* replaced with offset to start of .plt. */ 283}; 284 285/* The first entry in a PIC procedure linkage table look like this. */ 286 287static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] = 288{ 289 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */ 290 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */ 291 0, 0, 0, 0 /* pad out to 16 bytes. */ 292}; 293 294/* Subsequent entries in a PIC procedure linkage table look like this. */ 295 296static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] = 297{ 298 0xff, 0xa3, /* jmp *offset(%ebx) */ 299 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */ 300 0x68, /* pushl immediate */ 301 0, 0, 0, 0, /* replaced with offset into relocation table. */ 302 0xe9, /* jmp relative */ 303 0, 0, 0, 0 /* replaced with offset to start of .plt. */ 304}; 305 306/* The i386 linker needs to keep track of the number of relocs that it 307 decides to copy in check_relocs for each symbol. This is so that 308 it can discard PC relative relocs if it doesn't need them when 309 linking with -Bsymbolic. We store the information in a field 310 extending the regular ELF linker hash table. */ 311 312/* This structure keeps track of the number of PC relative relocs we 313 have copied for a given symbol. */ 314 315struct elf_i386_pcrel_relocs_copied 316{ 317 /* Next section. */ 318 struct elf_i386_pcrel_relocs_copied *next; 319 /* A section in dynobj. */ 320 asection *section; 321 /* Number of relocs copied in this section. */ 322 bfd_size_type count; 323}; 324 325/* i386 ELF linker hash entry. */ 326 327struct elf_i386_link_hash_entry 328{ 329 struct elf_link_hash_entry root; 330 331 /* Number of PC relative relocs copied for this symbol. */ 332 struct elf_i386_pcrel_relocs_copied *pcrel_relocs_copied; 333}; 334 335/* i386 ELF linker hash table. */ 336 337struct elf_i386_link_hash_table 338{ 339 struct elf_link_hash_table root; 340}; 341 342/* Declare this now that the above structures are defined. */ 343 344static boolean elf_i386_discard_copies 345 PARAMS ((struct elf_i386_link_hash_entry *, PTR)); 346 347/* Traverse an i386 ELF linker hash table. */ 348 349#define elf_i386_link_hash_traverse(table, func, info) \ 350 (elf_link_hash_traverse \ 351 (&(table)->root, \ 352 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \ 353 (info))) 354 355/* Get the i386 ELF linker hash table from a link_info structure. */ 356 357#define elf_i386_hash_table(p) \ 358 ((struct elf_i386_link_hash_table *) ((p)->hash)) 359 360/* Create an entry in an i386 ELF linker hash table. */ 361 362static struct bfd_hash_entry * 363elf_i386_link_hash_newfunc (entry, table, string) 364 struct bfd_hash_entry *entry; 365 struct bfd_hash_table *table; 366 const char *string; 367{ 368 struct elf_i386_link_hash_entry *ret = 369 (struct elf_i386_link_hash_entry *) entry; 370 371 /* Allocate the structure if it has not already been allocated by a 372 subclass. */ 373 if (ret == (struct elf_i386_link_hash_entry *) NULL) 374 ret = ((struct elf_i386_link_hash_entry *) 375 bfd_hash_allocate (table, 376 sizeof (struct elf_i386_link_hash_entry))); 377 if (ret == (struct elf_i386_link_hash_entry *) NULL) 378 return (struct bfd_hash_entry *) ret; 379 380 /* Call the allocation method of the superclass. */ 381 ret = ((struct elf_i386_link_hash_entry *) 382 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, 383 table, string)); 384 if (ret != (struct elf_i386_link_hash_entry *) NULL) 385 { 386 ret->pcrel_relocs_copied = NULL; 387 } 388 389 return (struct bfd_hash_entry *) ret; 390} 391 392/* Create an i386 ELF linker hash table. */ 393 394static struct bfd_link_hash_table * 395elf_i386_link_hash_table_create (abfd) 396 bfd *abfd; 397{ 398 struct elf_i386_link_hash_table *ret; 399 400 ret = ((struct elf_i386_link_hash_table *) 401 bfd_alloc (abfd, sizeof (struct elf_i386_link_hash_table))); 402 if (ret == (struct elf_i386_link_hash_table *) NULL) 403 return NULL; 404 405 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd, 406 elf_i386_link_hash_newfunc)) 407 { 408 bfd_release (abfd, ret); 409 return NULL; 410 } 411 412 return &ret->root.root; 413} 414 415/* Look through the relocs for a section during the first phase, and 416 allocate space in the global offset table or procedure linkage 417 table. */ 418 419static boolean 420elf_i386_check_relocs (abfd, info, sec, relocs) 421 bfd *abfd; 422 struct bfd_link_info *info; 423 asection *sec; 424 const Elf_Internal_Rela *relocs; 425{ 426 bfd *dynobj; 427 Elf_Internal_Shdr *symtab_hdr; 428 struct elf_link_hash_entry **sym_hashes; 429 bfd_vma *local_got_offsets; 430 const Elf_Internal_Rela *rel; 431 const Elf_Internal_Rela *rel_end; 432 asection *sgot; 433 asection *srelgot; 434 asection *sreloc; 435 436 if (info->relocateable) 437 return true; 438 439 dynobj = elf_hash_table (info)->dynobj; 440 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 441 sym_hashes = elf_sym_hashes (abfd); 442 local_got_offsets = elf_local_got_offsets (abfd); 443 444 sgot = NULL; 445 srelgot = NULL; 446 sreloc = NULL; 447 448 rel_end = relocs + sec->reloc_count; 449 for (rel = relocs; rel < rel_end; rel++) 450 { 451 unsigned long r_symndx; 452 struct elf_link_hash_entry *h; 453 454 r_symndx = ELF32_R_SYM (rel->r_info); 455 456 if (r_symndx < symtab_hdr->sh_info) 457 h = NULL; 458 else 459 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 460 461 /* Some relocs require a global offset table. */ 462 if (dynobj == NULL) 463 { 464 switch (ELF32_R_TYPE (rel->r_info)) 465 { 466 case R_386_GOT32: 467 case R_386_GOTOFF: 468 case R_386_GOTPC: 469 elf_hash_table (info)->dynobj = dynobj = abfd; 470 if (! _bfd_elf_create_got_section (dynobj, info)) 471 return false; 472 break; 473 474 default: 475 break; 476 } 477 } 478 479 switch (ELF32_R_TYPE (rel->r_info)) 480 { 481 case R_386_GOT32: 482 /* This symbol requires a global offset table entry. */ 483 484 if (sgot == NULL) 485 { 486 sgot = bfd_get_section_by_name (dynobj, ".got"); 487 BFD_ASSERT (sgot != NULL); 488 } 489 490 if (srelgot == NULL 491 && (h != NULL || info->shared)) 492 { 493 srelgot = bfd_get_section_by_name (dynobj, ".rel.got"); 494 if (srelgot == NULL) 495 { 496 srelgot = bfd_make_section (dynobj, ".rel.got"); 497 if (srelgot == NULL 498 || ! bfd_set_section_flags (dynobj, srelgot, 499 (SEC_ALLOC 500 | SEC_LOAD 501 | SEC_HAS_CONTENTS 502 | SEC_IN_MEMORY 503 | SEC_LINKER_CREATED 504 | SEC_READONLY)) 505 || ! bfd_set_section_alignment (dynobj, srelgot, 2)) 506 return false; 507 } 508 } 509 510 if (h != NULL) 511 { 512 if (h->got_offset != (bfd_vma) -1) 513 { 514 /* We have already allocated space in the .got. */ 515 break; 516 } 517 h->got_offset = sgot->_raw_size; 518 519 /* Make sure this symbol is output as a dynamic symbol. */ 520 if (h->dynindx == -1) 521 { 522 if (! bfd_elf32_link_record_dynamic_symbol (info, h)) 523 return false; 524 } 525 526 srelgot->_raw_size += sizeof (Elf32_External_Rel); 527 } 528 else 529 { 530 /* This is a global offset table entry for a local 531 symbol. */ 532 if (local_got_offsets == NULL) 533 { 534 size_t size; 535 register unsigned int i; 536 537 size = symtab_hdr->sh_info * sizeof (bfd_vma); 538 local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size); 539 if (local_got_offsets == NULL) 540 return false; 541 elf_local_got_offsets (abfd) = local_got_offsets; 542 for (i = 0; i < symtab_hdr->sh_info; i++) 543 local_got_offsets[i] = (bfd_vma) -1; 544 } 545 if (local_got_offsets[r_symndx] != (bfd_vma) -1) 546 { 547 /* We have already allocated space in the .got. */ 548 break; 549 } 550 local_got_offsets[r_symndx] = sgot->_raw_size; 551 552 if (info->shared) 553 { 554 /* If we are generating a shared object, we need to 555 output a R_386_RELATIVE reloc so that the dynamic 556 linker can adjust this GOT entry. */ 557 srelgot->_raw_size += sizeof (Elf32_External_Rel); 558 } 559 } 560 561 sgot->_raw_size += 4; 562 563 break; 564 565 case R_386_PLT32: 566 /* This symbol requires a procedure linkage table entry. We 567 actually build the entry in adjust_dynamic_symbol, 568 because this might be a case of linking PIC code which is 569 never referenced by a dynamic object, in which case we 570 don't need to generate a procedure linkage table entry 571 after all. */ 572 573 /* If this is a local symbol, we resolve it directly without 574 creating a procedure linkage table entry. */ 575 if (h == NULL) 576 continue; 577 578 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT; 579 580 break; 581 582 case R_386_32: 583 case R_386_PC32: 584 /* If we are creating a shared library, and this is a reloc 585 against a global symbol, or a non PC relative reloc 586 against a local symbol, then we need to copy the reloc 587 into the shared library. However, if we are linking with 588 -Bsymbolic, we do not need to copy a reloc against a 589 global symbol which is defined in an object we are 590 including in the link (i.e., DEF_REGULAR is set). At 591 this point we have not seen all the input files, so it is 592 possible that DEF_REGULAR is not set now but will be set 593 later (it is never cleared). We account for that 594 possibility below by storing information in the 595 pcrel_relocs_copied field of the hash table entry. */ 596 if (info->shared 597 && (ELF32_R_TYPE (rel->r_info) != R_386_PC32 598 || (h != NULL 599 && (! info->symbolic 600 || (h->elf_link_hash_flags 601 & ELF_LINK_HASH_DEF_REGULAR) == 0)))) 602 { 603 /* When creating a shared object, we must copy these 604 reloc types into the output file. We create a reloc 605 section in dynobj and make room for this reloc. */ 606 if (sreloc == NULL) 607 { 608 const char *name; 609 610 name = (bfd_elf_string_from_elf_section 611 (abfd, 612 elf_elfheader (abfd)->e_shstrndx, 613 elf_section_data (sec)->rel_hdr.sh_name)); 614 if (name == NULL) 615 return false; 616 617 BFD_ASSERT (strncmp (name, ".rel", 4) == 0 618 && strcmp (bfd_get_section_name (abfd, sec), 619 name + 4) == 0); 620 621 sreloc = bfd_get_section_by_name (dynobj, name); 622 if (sreloc == NULL) 623 { 624 flagword flags; 625 626 sreloc = bfd_make_section (dynobj, name); 627 flags = (SEC_HAS_CONTENTS | SEC_READONLY 628 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 629 if ((sec->flags & SEC_ALLOC) != 0) 630 flags |= SEC_ALLOC | SEC_LOAD; 631 if (sreloc == NULL 632 || ! bfd_set_section_flags (dynobj, sreloc, flags) 633 || ! bfd_set_section_alignment (dynobj, sreloc, 2)) 634 return false; 635 } 636 } 637 638 sreloc->_raw_size += sizeof (Elf32_External_Rel); 639 640 /* If we are linking with -Bsymbolic, and this is a 641 global symbol, we count the number of PC relative 642 relocations we have entered for this symbol, so that 643 we can discard them again if the symbol is later 644 defined by a regular object. Note that this function 645 is only called if we are using an elf_i386 linker 646 hash table, which means that h is really a pointer to 647 an elf_i386_link_hash_entry. */ 648 if (h != NULL && info->symbolic 649 && ELF32_R_TYPE (rel->r_info) == R_386_PC32) 650 { 651 struct elf_i386_link_hash_entry *eh; 652 struct elf_i386_pcrel_relocs_copied *p; 653 654 eh = (struct elf_i386_link_hash_entry *) h; 655 656 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next) 657 if (p->section == sreloc) 658 break; 659 660 if (p == NULL) 661 { 662 p = ((struct elf_i386_pcrel_relocs_copied *) 663 bfd_alloc (dynobj, sizeof *p)); 664 if (p == NULL) 665 return false; 666 p->next = eh->pcrel_relocs_copied; 667 eh->pcrel_relocs_copied = p; 668 p->section = sreloc; 669 p->count = 0; 670 } 671 672 ++p->count; 673 } 674 } 675 676 break; 677 678 default: 679 break; 680 } 681 } 682 683 return true; 684} 685 686/* Adjust a symbol defined by a dynamic object and referenced by a 687 regular object. The current definition is in some section of the 688 dynamic object, but we're not including those sections. We have to 689 change the definition to something the rest of the link can 690 understand. */ 691 692static boolean 693elf_i386_adjust_dynamic_symbol (info, h) 694 struct bfd_link_info *info; 695 struct elf_link_hash_entry *h; 696{ 697 bfd *dynobj; 698 asection *s; 699 unsigned int power_of_two; 700 701 dynobj = elf_hash_table (info)->dynobj; 702 703 /* Make sure we know what is going on here. */ 704 BFD_ASSERT (dynobj != NULL 705 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) 706 || h->weakdef != NULL 707 || ((h->elf_link_hash_flags 708 & ELF_LINK_HASH_DEF_DYNAMIC) != 0 709 && (h->elf_link_hash_flags 710 & ELF_LINK_HASH_REF_REGULAR) != 0 711 && (h->elf_link_hash_flags 712 & ELF_LINK_HASH_DEF_REGULAR) == 0))); 713 714 /* If this is a function, put it in the procedure linkage table. We 715 will fill in the contents of the procedure linkage table later, 716 when we know the address of the .got section. */ 717 if (h->type == STT_FUNC 718 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0) 719 { 720 if (! info->shared 721 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0 722 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0) 723 { 724 /* This case can occur if we saw a PLT32 reloc in an input 725 file, but the symbol was never referred to by a dynamic 726 object. In such a case, we don't actually need to build 727 a procedure linkage table, and we can just do a PC32 728 reloc instead. */ 729 BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0); 730 return true; 731 } 732 733 /* Make sure this symbol is output as a dynamic symbol. */ 734 if (h->dynindx == -1) 735 { 736 if (! bfd_elf32_link_record_dynamic_symbol (info, h)) 737 return false; 738 } 739 740 s = bfd_get_section_by_name (dynobj, ".plt"); 741 BFD_ASSERT (s != NULL); 742 743 /* If this is the first .plt entry, make room for the special 744 first entry. */ 745 if (s->_raw_size == 0) 746 s->_raw_size += PLT_ENTRY_SIZE; 747 748 /* If this symbol is not defined in a regular file, and we are 749 not generating a shared library, then set the symbol to this 750 location in the .plt. This is required to make function 751 pointers compare as equal between the normal executable and 752 the shared library. */ 753 if (! info->shared 754 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 755 { 756 h->root.u.def.section = s; 757 h->root.u.def.value = s->_raw_size; 758 } 759 760 h->plt_offset = s->_raw_size; 761 762 /* Make room for this entry. */ 763 s->_raw_size += PLT_ENTRY_SIZE; 764 765 /* We also need to make an entry in the .got.plt section, which 766 will be placed in the .got section by the linker script. */ 767 768 s = bfd_get_section_by_name (dynobj, ".got.plt"); 769 BFD_ASSERT (s != NULL); 770 s->_raw_size += 4; 771 772 /* We also need to make an entry in the .rel.plt section. */ 773 774 s = bfd_get_section_by_name (dynobj, ".rel.plt"); 775 BFD_ASSERT (s != NULL); 776 s->_raw_size += sizeof (Elf32_External_Rel); 777 778 return true; 779 } 780 781 /* If this is a weak symbol, and there is a real definition, the 782 processor independent code will have arranged for us to see the 783 real definition first, and we can just use the same value. */ 784 if (h->weakdef != NULL) 785 { 786 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined 787 || h->weakdef->root.type == bfd_link_hash_defweak); 788 h->root.u.def.section = h->weakdef->root.u.def.section; 789 h->root.u.def.value = h->weakdef->root.u.def.value; 790 return true; 791 } 792 793 /* This is a reference to a symbol defined by a dynamic object which 794 is not a function. */ 795 796 /* If we are creating a shared library, we must presume that the 797 only references to the symbol are via the global offset table. 798 For such cases we need not do anything here; the relocations will 799 be handled correctly by relocate_section. */ 800 if (info->shared) 801 return true; 802 803 /* We must allocate the symbol in our .dynbss section, which will 804 become part of the .bss section of the executable. There will be 805 an entry for this symbol in the .dynsym section. The dynamic 806 object will contain position independent code, so all references 807 from the dynamic object to this symbol will go through the global 808 offset table. The dynamic linker will use the .dynsym entry to 809 determine the address it must put in the global offset table, so 810 both the dynamic object and the regular object will refer to the 811 same memory location for the variable. */ 812 813 s = bfd_get_section_by_name (dynobj, ".dynbss"); 814 BFD_ASSERT (s != NULL); 815 816 /* We must generate a R_386_COPY reloc to tell the dynamic linker to 817 copy the initial value out of the dynamic object and into the 818 runtime process image. We need to remember the offset into the 819 .rel.bss section we are going to use. */ 820 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 821 { 822 asection *srel; 823 824 srel = bfd_get_section_by_name (dynobj, ".rel.bss"); 825 BFD_ASSERT (srel != NULL); 826 srel->_raw_size += sizeof (Elf32_External_Rel); 827 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY; 828 } 829 830 /* We need to figure out the alignment required for this symbol. I 831 have no idea how ELF linkers handle this. */ 832 power_of_two = bfd_log2 (h->size); 833 if (power_of_two > 3) 834 power_of_two = 3; 835 836 /* Apply the required alignment. */ 837 s->_raw_size = BFD_ALIGN (s->_raw_size, 838 (bfd_size_type) (1 << power_of_two)); 839 if (power_of_two > bfd_get_section_alignment (dynobj, s)) 840 { 841 if (! bfd_set_section_alignment (dynobj, s, power_of_two)) 842 return false; 843 } 844 845 /* Define the symbol as being at this point in the section. */ 846 h->root.u.def.section = s; 847 h->root.u.def.value = s->_raw_size; 848 849 /* Increment the section size to make room for the symbol. */ 850 s->_raw_size += h->size; 851 852 return true; 853} 854 855/* Set the sizes of the dynamic sections. */ 856 857static boolean 858elf_i386_size_dynamic_sections (output_bfd, info) 859 bfd *output_bfd; 860 struct bfd_link_info *info; 861{ 862 bfd *dynobj; 863 asection *s; 864 boolean plt; 865 boolean relocs; 866 boolean reltext; 867 868 dynobj = elf_hash_table (info)->dynobj; 869 BFD_ASSERT (dynobj != NULL); 870 871 if (elf_hash_table (info)->dynamic_sections_created) 872 { 873 /* Set the contents of the .interp section to the interpreter. */ 874 if (! info->shared) 875 { 876 s = bfd_get_section_by_name (dynobj, ".interp"); 877 BFD_ASSERT (s != NULL); 878 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER; 879 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 880 } 881 } 882 else 883 { 884 /* We may have created entries in the .rel.got section. 885 However, if we are not creating the dynamic sections, we will 886 not actually use these entries. Reset the size of .rel.got, 887 which will cause it to get stripped from the output file 888 below. */ 889 s = bfd_get_section_by_name (dynobj, ".rel.got"); 890 if (s != NULL) 891 s->_raw_size = 0; 892 } 893 894 /* If this is a -Bsymbolic shared link, then we need to discard all 895 PC relative relocs against symbols defined in a regular object. 896 We allocated space for them in the check_relocs routine, but we 897 will not fill them in in the relocate_section routine. */ 898 if (info->shared && info->symbolic) 899 elf_i386_link_hash_traverse (elf_i386_hash_table (info), 900 elf_i386_discard_copies, 901 (PTR) NULL); 902 903 /* The check_relocs and adjust_dynamic_symbol entry points have 904 determined the sizes of the various dynamic sections. Allocate 905 memory for them. */ 906 plt = false; 907 relocs = false; 908 reltext = false; 909 for (s = dynobj->sections; s != NULL; s = s->next) 910 { 911 const char *name; 912 boolean strip; 913 914 if ((s->flags & SEC_LINKER_CREATED) == 0) 915 continue; 916 917 /* It's OK to base decisions on the section name, because none 918 of the dynobj section names depend upon the input files. */ 919 name = bfd_get_section_name (dynobj, s); 920 921 strip = false; 922 923 if (strcmp (name, ".plt") == 0) 924 { 925 if (s->_raw_size == 0) 926 { 927 /* Strip this section if we don't need it; see the 928 comment below. */ 929 strip = true; 930 } 931 else 932 { 933 /* Remember whether there is a PLT. */ 934 plt = true; 935 } 936 } 937 else if (strncmp (name, ".rel", 4) == 0) 938 { 939 if (s->_raw_size == 0) 940 { 941 /* If we don't need this section, strip it from the 942 output file. This is mostly to handle .rel.bss and 943 .rel.plt. We must create both sections in 944 create_dynamic_sections, because they must be created 945 before the linker maps input sections to output 946 sections. The linker does that before 947 adjust_dynamic_symbol is called, and it is that 948 function which decides whether anything needs to go 949 into these sections. */ 950 strip = true; 951 } 952 else 953 { 954 asection *target; 955 956 /* Remember whether there are any reloc sections other 957 than .rel.plt. */ 958 if (strcmp (name, ".rel.plt") != 0) 959 { 960 const char *outname; 961 962 relocs = true; 963 964 /* If this relocation section applies to a read only 965 section which is in memory at run time, then 966 we probably need a DT_TEXTREL entry. The entries 967 in the .rel.plt section really apply to the 968 .got section, which we created ourselves and so 969 know is not readonly. */ 970 outname = bfd_get_section_name (output_bfd, 971 s->output_section); 972 target = bfd_get_section_by_name (output_bfd, outname + 4); 973 if (target != NULL 974 && (target->flags & SEC_READONLY) != 0 975 && (target->flags & SEC_ALLOC) != 0) 976 reltext = true; 977 } 978 979 /* We use the reloc_count field as a counter if we need 980 to copy relocs into the output file. */ 981 s->reloc_count = 0; 982 } 983 } 984 else if (strncmp (name, ".got", 4) != 0) 985 { 986 /* It's not one of our sections, so don't allocate space. */ 987 continue; 988 } 989 990 if (strip) 991 { 992 asection **spp; 993 994 for (spp = &s->output_section->owner->sections; 995 *spp != s->output_section; 996 spp = &(*spp)->next) 997 ; 998 *spp = s->output_section->next; 999 --s->output_section->owner->section_count; 1000 1001 continue; 1002 } 1003 1004 /* Allocate memory for the section contents. */ 1005 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size); 1006 if (s->contents == NULL && s->_raw_size != 0) 1007 return false; 1008 } 1009 1010 if (elf_hash_table (info)->dynamic_sections_created) 1011 { 1012 /* Add some entries to the .dynamic section. We fill in the 1013 values later, in elf_i386_finish_dynamic_sections, but we 1014 must add the entries now so that we get the correct size for 1015 the .dynamic section. The DT_DEBUG entry is filled in by the 1016 dynamic linker and used by the debugger. */ 1017 if (! info->shared) 1018 { 1019 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0)) 1020 return false; 1021 } 1022 1023 if (plt) 1024 { 1025 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0) 1026 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0) 1027 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL) 1028 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0)) 1029 return false; 1030 } 1031 1032 if (relocs) 1033 { 1034 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0) 1035 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0) 1036 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT, 1037 sizeof (Elf32_External_Rel))) 1038 return false; 1039 } 1040 1041 if (reltext) 1042 { 1043 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0)) 1044 return false; 1045 } 1046 } 1047 1048 return true; 1049} 1050 1051/* This function is called via elf_i386_link_hash_traverse if we are 1052 creating a shared object with -Bsymbolic. It discards the space 1053 allocated to copy PC relative relocs against symbols which are 1054 defined in regular objects. We allocated space for them in the 1055 check_relocs routine, but we won't fill them in in the 1056 relocate_section routine. */ 1057 1058/*ARGSUSED*/ 1059static boolean 1060elf_i386_discard_copies (h, ignore) 1061 struct elf_i386_link_hash_entry *h; 1062 PTR ignore; 1063{ 1064 struct elf_i386_pcrel_relocs_copied *s; 1065 1066 /* We only discard relocs for symbols defined in a regular object. */ 1067 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 1068 return true; 1069 1070 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next) 1071 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel); 1072 1073 return true; 1074} 1075 1076/* Relocate an i386 ELF section. */ 1077 1078static boolean 1079elf_i386_relocate_section (output_bfd, info, input_bfd, input_section, 1080 contents, relocs, local_syms, local_sections) 1081 bfd *output_bfd; 1082 struct bfd_link_info *info; 1083 bfd *input_bfd; 1084 asection *input_section; 1085 bfd_byte *contents; 1086 Elf_Internal_Rela *relocs; 1087 Elf_Internal_Sym *local_syms; 1088 asection **local_sections; 1089{ 1090 bfd *dynobj; 1091 Elf_Internal_Shdr *symtab_hdr; 1092 struct elf_link_hash_entry **sym_hashes; 1093 bfd_vma *local_got_offsets; 1094 asection *sgot; 1095 asection *splt; 1096 asection *sreloc; 1097 Elf_Internal_Rela *rel; 1098 Elf_Internal_Rela *relend; 1099 1100 dynobj = elf_hash_table (info)->dynobj; 1101 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1102 sym_hashes = elf_sym_hashes (input_bfd); 1103 local_got_offsets = elf_local_got_offsets (input_bfd); 1104 1105 sgot = NULL; 1106 splt = NULL; 1107 sreloc = NULL; 1108 1109 rel = relocs; 1110 relend = relocs + input_section->reloc_count; 1111 for (; rel < relend; rel++) 1112 { 1113 int r_type; 1114 reloc_howto_type *howto; 1115 unsigned long r_symndx; 1116 struct elf_link_hash_entry *h; 1117 Elf_Internal_Sym *sym; 1118 asection *sec; 1119 bfd_vma relocation; 1120 bfd_reloc_status_type r; 1121 1122 r_type = ELF32_R_TYPE (rel->r_info); 1123 if (r_type < 0 1124 || r_type >= (int) R_386_max 1125 || (r_type >= (int) FIRST_INVALID_RELOC 1126 && r_type <= (int) LAST_INVALID_RELOC)) 1127 { 1128 bfd_set_error (bfd_error_bad_value); 1129 return false; 1130 } 1131 howto = elf_howto_table + r_type; 1132 1133 r_symndx = ELF32_R_SYM (rel->r_info); 1134 1135 if (info->relocateable) 1136 { 1137 /* This is a relocateable link. We don't have to change 1138 anything, unless the reloc is against a section symbol, 1139 in which case we have to adjust according to where the 1140 section symbol winds up in the output section. */ 1141 if (r_symndx < symtab_hdr->sh_info) 1142 { 1143 sym = local_syms + r_symndx; 1144 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 1145 { 1146 bfd_vma val; 1147 1148 sec = local_sections[r_symndx]; 1149 val = bfd_get_32 (input_bfd, contents + rel->r_offset); 1150 val += sec->output_offset + sym->st_value; 1151 bfd_put_32 (input_bfd, val, contents + rel->r_offset); 1152 } 1153 } 1154 1155 continue; 1156 } 1157 1158 /* This is a final link. */ 1159 h = NULL; 1160 sym = NULL; 1161 sec = NULL; 1162 if (r_symndx < symtab_hdr->sh_info) 1163 { 1164 sym = local_syms + r_symndx; 1165 sec = local_sections[r_symndx]; 1166 relocation = (sec->output_section->vma 1167 + sec->output_offset 1168 + sym->st_value); 1169 } 1170 else 1171 { 1172 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1173 while (h->root.type == bfd_link_hash_indirect 1174 || h->root.type == bfd_link_hash_warning) 1175 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1176 if (h->root.type == bfd_link_hash_defined 1177 || h->root.type == bfd_link_hash_defweak) 1178 { 1179 sec = h->root.u.def.section; 1180 if (r_type == R_386_GOTPC 1181 || (r_type == R_386_PLT32 1182 && h->plt_offset != (bfd_vma) -1) 1183 || (r_type == R_386_GOT32 1184 && elf_hash_table (info)->dynamic_sections_created 1185 && (! info->shared 1186 || (! info->symbolic && h->dynindx != -1) 1187 || (h->elf_link_hash_flags 1188 & ELF_LINK_HASH_DEF_REGULAR) == 0)) 1189 || (info->shared 1190 && ((! info->symbolic && h->dynindx != -1) 1191 || (h->elf_link_hash_flags 1192 & ELF_LINK_HASH_DEF_REGULAR) == 0) 1193 && (r_type == R_386_32 1194 || r_type == R_386_PC32) 1195 && (input_section->flags & SEC_ALLOC) != 0)) 1196 { 1197 /* In these cases, we don't need the relocation 1198 value. We check specially because in some 1199 obscure cases sec->output_section will be NULL. */ 1200 relocation = 0; 1201 } 1202 else if (sec->output_section == NULL) 1203 { 1204 (*_bfd_error_handler) 1205 ("%s: warning: unresolvable relocation against symbol `%s' from %s section", 1206 bfd_get_filename (input_bfd), h->root.root.string, 1207 bfd_get_section_name (input_bfd, input_section)); 1208 relocation = 0; 1209 } 1210 else 1211 relocation = (h->root.u.def.value 1212 + sec->output_section->vma 1213 + sec->output_offset); 1214 } 1215 else if (h->root.type == bfd_link_hash_undefweak) 1216 relocation = 0; 1217 else if (info->shared && !info->symbolic) 1218 relocation = 0; 1219 else 1220 { 1221 if (! ((*info->callbacks->undefined_symbol) 1222 (info, h->root.root.string, input_bfd, 1223 input_section, rel->r_offset))) 1224 return false; 1225 relocation = 0; 1226 } 1227 } 1228 1229 switch (r_type) 1230 { 1231 case R_386_GOT32: 1232 /* Relocation is to the entry for this symbol in the global 1233 offset table. */ 1234 if (sgot == NULL) 1235 { 1236 sgot = bfd_get_section_by_name (dynobj, ".got"); 1237 BFD_ASSERT (sgot != NULL); 1238 } 1239 1240 if (h != NULL) 1241 { 1242 bfd_vma off; 1243 1244 off = h->got_offset; 1245 BFD_ASSERT (off != (bfd_vma) -1); 1246 1247 if (! elf_hash_table (info)->dynamic_sections_created 1248 || (info->shared 1249 && (info->symbolic || h->dynindx == -1) 1250 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))) 1251 { 1252 /* This is actually a static link, or it is a 1253 -Bsymbolic link and the symbol is defined 1254 locally, or the symbol was forced to be local 1255 because of a version file. We must initialize 1256 this entry in the global offset table. Since the 1257 offset must always be a multiple of 4, we use the 1258 least significant bit to record whether we have 1259 initialized it already. 1260 1261 When doing a dynamic link, we create a .rel.got 1262 relocation entry to initialize the value. This 1263 is done in the finish_dynamic_symbol routine. */ 1264 if ((off & 1) != 0) 1265 off &= ~1; 1266 else 1267 { 1268 bfd_put_32 (output_bfd, relocation, 1269 sgot->contents + off); 1270 h->got_offset |= 1; 1271 } 1272 } 1273 1274 relocation = sgot->output_offset + off; 1275 } 1276 else 1277 { 1278 bfd_vma off; 1279 1280 BFD_ASSERT (local_got_offsets != NULL 1281 && local_got_offsets[r_symndx] != (bfd_vma) -1); 1282 1283 off = local_got_offsets[r_symndx]; 1284 1285 /* The offset must always be a multiple of 4. We use 1286 the least significant bit to record whether we have 1287 already generated the necessary reloc. */ 1288 if ((off & 1) != 0) 1289 off &= ~1; 1290 else 1291 { 1292 bfd_put_32 (output_bfd, relocation, sgot->contents + off); 1293 1294 if (info->shared) 1295 { 1296 asection *srelgot; 1297 Elf_Internal_Rel outrel; 1298 1299 srelgot = bfd_get_section_by_name (dynobj, ".rel.got"); 1300 BFD_ASSERT (srelgot != NULL); 1301 1302 outrel.r_offset = (sgot->output_section->vma 1303 + sgot->output_offset 1304 + off); 1305 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE); 1306 bfd_elf32_swap_reloc_out (output_bfd, &outrel, 1307 (((Elf32_External_Rel *) 1308 srelgot->contents) 1309 + srelgot->reloc_count)); 1310 ++srelgot->reloc_count; 1311 } 1312 1313 local_got_offsets[r_symndx] |= 1; 1314 } 1315 1316 relocation = sgot->output_offset + off; 1317 } 1318 1319 break; 1320 1321 case R_386_GOTOFF: 1322 /* Relocation is relative to the start of the global offset 1323 table. */ 1324 1325 if (sgot == NULL) 1326 { 1327 sgot = bfd_get_section_by_name (dynobj, ".got"); 1328 BFD_ASSERT (sgot != NULL); 1329 } 1330 1331 /* Note that sgot->output_offset is not involved in this 1332 calculation. We always want the start of .got. If we 1333 defined _GLOBAL_OFFSET_TABLE in a different way, as is 1334 permitted by the ABI, we might have to change this 1335 calculation. */ 1336 relocation -= sgot->output_section->vma; 1337 1338 break; 1339 1340 case R_386_GOTPC: 1341 /* Use global offset table as symbol value. */ 1342 1343 if (sgot == NULL) 1344 { 1345 sgot = bfd_get_section_by_name (dynobj, ".got"); 1346 BFD_ASSERT (sgot != NULL); 1347 } 1348 1349 relocation = sgot->output_section->vma; 1350 1351 break; 1352 1353 case R_386_PLT32: 1354 /* Relocation is to the entry for this symbol in the 1355 procedure linkage table. */ 1356 1357 /* Resolve a PLT32 reloc again a local symbol directly, 1358 without using the procedure linkage table. */ 1359 if (h == NULL) 1360 break; 1361 1362 if (h->plt_offset == (bfd_vma) -1) 1363 { 1364 /* We didn't make a PLT entry for this symbol. This 1365 happens when statically linking PIC code, or when 1366 using -Bsymbolic. */ 1367 break; 1368 } 1369 1370 if (splt == NULL) 1371 { 1372 splt = bfd_get_section_by_name (dynobj, ".plt"); 1373 BFD_ASSERT (splt != NULL); 1374 } 1375 1376 relocation = (splt->output_section->vma 1377 + splt->output_offset 1378 + h->plt_offset); 1379 1380 break; 1381 1382 case R_386_32: 1383 case R_386_PC32: 1384 if (info->shared 1385 && (r_type != R_386_PC32 1386 || (h != NULL 1387 && h->dynindx != -1 1388 && (! info->symbolic 1389 || (h->elf_link_hash_flags 1390 & ELF_LINK_HASH_DEF_REGULAR) == 0)))) 1391 { 1392 Elf_Internal_Rel outrel; 1393 boolean skip, relocate; 1394 1395 /* When generating a shared object, these relocations 1396 are copied into the output file to be resolved at run 1397 time. */ 1398 1399 if (sreloc == NULL) 1400 { 1401 const char *name; 1402 1403 name = (bfd_elf_string_from_elf_section 1404 (input_bfd, 1405 elf_elfheader (input_bfd)->e_shstrndx, 1406 elf_section_data (input_section)->rel_hdr.sh_name)); 1407 if (name == NULL) 1408 return false; 1409 1410 BFD_ASSERT (strncmp (name, ".rel", 4) == 0 1411 && strcmp (bfd_get_section_name (input_bfd, 1412 input_section), 1413 name + 4) == 0); 1414 1415 sreloc = bfd_get_section_by_name (dynobj, name); 1416 BFD_ASSERT (sreloc != NULL); 1417 } 1418 1419 skip = false; 1420 1421 if (elf_section_data (input_section)->stab_info == NULL) 1422 outrel.r_offset = rel->r_offset; 1423 else 1424 { 1425 bfd_vma off; 1426 1427 off = (_bfd_stab_section_offset 1428 (output_bfd, &elf_hash_table (info)->stab_info, 1429 input_section, 1430 &elf_section_data (input_section)->stab_info, 1431 rel->r_offset)); 1432 if (off == (bfd_vma) -1) 1433 skip = true; 1434 outrel.r_offset = off; 1435 } 1436 1437 outrel.r_offset += (input_section->output_section->vma 1438 + input_section->output_offset); 1439 1440 if (skip) 1441 { 1442 memset (&outrel, 0, sizeof outrel); 1443 relocate = false; 1444 } 1445 else if (r_type == R_386_PC32) 1446 { 1447 BFD_ASSERT (h != NULL && h->dynindx != -1); 1448 if ((input_section->flags & SEC_ALLOC) != 0) 1449 relocate = false; 1450 else 1451 relocate = true; 1452 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_PC32); 1453 } 1454 else 1455 { 1456 /* h->dynindx may be -1 if this symbol was marked to 1457 become local. */ 1458 if (h == NULL 1459 || ((info->symbolic || h->dynindx == -1) 1460 && (h->elf_link_hash_flags 1461 & ELF_LINK_HASH_DEF_REGULAR) != 0)) 1462 { 1463 relocate = true; 1464 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE); 1465 } 1466 else 1467 { 1468 BFD_ASSERT (h->dynindx != -1); 1469 if ((input_section->flags & SEC_ALLOC) != 0) 1470 relocate = false; 1471 else 1472 relocate = true; 1473 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_32); 1474 } 1475 } 1476 1477 bfd_elf32_swap_reloc_out (output_bfd, &outrel, 1478 (((Elf32_External_Rel *) 1479 sreloc->contents) 1480 + sreloc->reloc_count)); 1481 ++sreloc->reloc_count; 1482 1483 /* If this reloc is against an external symbol, we do 1484 not want to fiddle with the addend. Otherwise, we 1485 need to include the symbol value so that it becomes 1486 an addend for the dynamic reloc. */ 1487 if (! relocate) 1488 continue; 1489 } 1490 1491 break; 1492 1493 default: 1494 break; 1495 } 1496 1497 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 1498 contents, rel->r_offset, 1499 relocation, (bfd_vma) 0); 1500 1501 if (r != bfd_reloc_ok) 1502 { 1503 switch (r) 1504 { 1505 default: 1506 case bfd_reloc_outofrange: 1507 abort (); 1508 case bfd_reloc_overflow: 1509 { 1510 const char *name; 1511 1512 if (h != NULL) 1513 name = h->root.root.string; 1514 else 1515 { 1516 name = bfd_elf_string_from_elf_section (input_bfd, 1517 symtab_hdr->sh_link, 1518 sym->st_name); 1519 if (name == NULL) 1520 return false; 1521 if (*name == '\0') 1522 name = bfd_section_name (input_bfd, sec); 1523 } 1524 if (! ((*info->callbacks->reloc_overflow) 1525 (info, name, howto->name, (bfd_vma) 0, 1526 input_bfd, input_section, rel->r_offset))) 1527 return false; 1528 } 1529 break; 1530 } 1531 } 1532 } 1533 1534 return true; 1535} 1536 1537/* Finish up dynamic symbol handling. We set the contents of various 1538 dynamic sections here. */ 1539 1540static boolean 1541elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym) 1542 bfd *output_bfd; 1543 struct bfd_link_info *info; 1544 struct elf_link_hash_entry *h; 1545 Elf_Internal_Sym *sym; 1546{ 1547 bfd *dynobj; 1548 1549 dynobj = elf_hash_table (info)->dynobj; 1550 1551 if (h->plt_offset != (bfd_vma) -1) 1552 { 1553 asection *splt; 1554 asection *sgot; 1555 asection *srel; 1556 bfd_vma plt_index; 1557 bfd_vma got_offset; 1558 Elf_Internal_Rel rel; 1559 1560 /* This symbol has an entry in the procedure linkage table. Set 1561 it up. */ 1562 1563 BFD_ASSERT (h->dynindx != -1); 1564 1565 splt = bfd_get_section_by_name (dynobj, ".plt"); 1566 sgot = bfd_get_section_by_name (dynobj, ".got.plt"); 1567 srel = bfd_get_section_by_name (dynobj, ".rel.plt"); 1568 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL); 1569 1570 /* Get the index in the procedure linkage table which 1571 corresponds to this symbol. This is the index of this symbol 1572 in all the symbols for which we are making plt entries. The 1573 first entry in the procedure linkage table is reserved. */ 1574 plt_index = h->plt_offset / PLT_ENTRY_SIZE - 1; 1575 1576 /* Get the offset into the .got table of the entry that 1577 corresponds to this function. Each .got entry is 4 bytes. 1578 The first three are reserved. */ 1579 got_offset = (plt_index + 3) * 4; 1580 1581 /* Fill in the entry in the procedure linkage table. */ 1582 if (! info->shared) 1583 { 1584 memcpy (splt->contents + h->plt_offset, elf_i386_plt_entry, 1585 PLT_ENTRY_SIZE); 1586 bfd_put_32 (output_bfd, 1587 (sgot->output_section->vma 1588 + sgot->output_offset 1589 + got_offset), 1590 splt->contents + h->plt_offset + 2); 1591 } 1592 else 1593 { 1594 memcpy (splt->contents + h->plt_offset, elf_i386_pic_plt_entry, 1595 PLT_ENTRY_SIZE); 1596 bfd_put_32 (output_bfd, got_offset, 1597 splt->contents + h->plt_offset + 2); 1598 } 1599 1600 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel), 1601 splt->contents + h->plt_offset + 7); 1602 bfd_put_32 (output_bfd, - (h->plt_offset + PLT_ENTRY_SIZE), 1603 splt->contents + h->plt_offset + 12); 1604 1605 /* Fill in the entry in the global offset table. */ 1606 bfd_put_32 (output_bfd, 1607 (splt->output_section->vma 1608 + splt->output_offset 1609 + h->plt_offset 1610 + 6), 1611 sgot->contents + got_offset); 1612 1613 /* Fill in the entry in the .rel.plt section. */ 1614 rel.r_offset = (sgot->output_section->vma 1615 + sgot->output_offset 1616 + got_offset); 1617 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT); 1618 bfd_elf32_swap_reloc_out (output_bfd, &rel, 1619 ((Elf32_External_Rel *) srel->contents 1620 + plt_index)); 1621 1622 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 1623 { 1624 /* Mark the symbol as undefined, rather than as defined in 1625 the .plt section. Leave the value alone. */ 1626 sym->st_shndx = SHN_UNDEF; 1627 } 1628 } 1629 1630 if (h->got_offset != (bfd_vma) -1) 1631 { 1632 asection *sgot; 1633 asection *srel; 1634 Elf_Internal_Rel rel; 1635 1636 /* This symbol has an entry in the global offset table. Set it 1637 up. */ 1638 1639 sgot = bfd_get_section_by_name (dynobj, ".got"); 1640 srel = bfd_get_section_by_name (dynobj, ".rel.got"); 1641 BFD_ASSERT (sgot != NULL && srel != NULL); 1642 1643 rel.r_offset = (sgot->output_section->vma 1644 + sgot->output_offset 1645 + (h->got_offset &~ 1)); 1646 1647 /* If this is a -Bsymbolic link, and the symbol is defined 1648 locally, we just want to emit a RELATIVE reloc. Likewise if 1649 the symbol was forced to be local because of a version file. 1650 The entry in the global offset table will already have been 1651 initialized in the relocate_section function. */ 1652 if (info->shared 1653 && (info->symbolic || h->dynindx == -1) 1654 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)) 1655 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE); 1656 else 1657 { 1658 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got_offset); 1659 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT); 1660 } 1661 1662 bfd_elf32_swap_reloc_out (output_bfd, &rel, 1663 ((Elf32_External_Rel *) srel->contents 1664 + srel->reloc_count)); 1665 ++srel->reloc_count; 1666 } 1667 1668 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0) 1669 { 1670 asection *s; 1671 Elf_Internal_Rel rel; 1672 1673 /* This symbol needs a copy reloc. Set it up. */ 1674 1675 BFD_ASSERT (h->dynindx != -1 1676 && (h->root.type == bfd_link_hash_defined 1677 || h->root.type == bfd_link_hash_defweak)); 1678 1679 s = bfd_get_section_by_name (h->root.u.def.section->owner, 1680 ".rel.bss"); 1681 BFD_ASSERT (s != NULL); 1682 1683 rel.r_offset = (h->root.u.def.value 1684 + h->root.u.def.section->output_section->vma 1685 + h->root.u.def.section->output_offset); 1686 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY); 1687 bfd_elf32_swap_reloc_out (output_bfd, &rel, 1688 ((Elf32_External_Rel *) s->contents 1689 + s->reloc_count)); 1690 ++s->reloc_count; 1691 } 1692 1693 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 1694 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 1695 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 1696 sym->st_shndx = SHN_ABS; 1697 1698 return true; 1699} 1700 1701/* Finish up the dynamic sections. */ 1702 1703static boolean 1704elf_i386_finish_dynamic_sections (output_bfd, info) 1705 bfd *output_bfd; 1706 struct bfd_link_info *info; 1707{ 1708 bfd *dynobj; 1709 asection *sgot; 1710 asection *sdyn; 1711 1712 dynobj = elf_hash_table (info)->dynobj; 1713 1714 sgot = bfd_get_section_by_name (dynobj, ".got.plt"); 1715 BFD_ASSERT (sgot != NULL); 1716 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 1717 1718 if (elf_hash_table (info)->dynamic_sections_created) 1719 { 1720 asection *splt; 1721 Elf32_External_Dyn *dyncon, *dynconend; 1722 1723 splt = bfd_get_section_by_name (dynobj, ".plt"); 1724 BFD_ASSERT (splt != NULL && sdyn != NULL); 1725 1726 dyncon = (Elf32_External_Dyn *) sdyn->contents; 1727 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size); 1728 for (; dyncon < dynconend; dyncon++) 1729 { 1730 Elf_Internal_Dyn dyn; 1731 const char *name; 1732 asection *s; 1733 1734 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 1735 1736 switch (dyn.d_tag) 1737 { 1738 default: 1739 break; 1740 1741 case DT_PLTGOT: 1742 name = ".got"; 1743 goto get_vma; 1744 case DT_JMPREL: 1745 name = ".rel.plt"; 1746 get_vma: 1747 s = bfd_get_section_by_name (output_bfd, name); 1748 BFD_ASSERT (s != NULL); 1749 dyn.d_un.d_ptr = s->vma; 1750 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 1751 break; 1752 1753 case DT_PLTRELSZ: 1754 s = bfd_get_section_by_name (output_bfd, ".rel.plt"); 1755 BFD_ASSERT (s != NULL); 1756 if (s->_cooked_size != 0) 1757 dyn.d_un.d_val = s->_cooked_size; 1758 else 1759 dyn.d_un.d_val = s->_raw_size; 1760 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 1761 break; 1762 1763 case DT_RELSZ: 1764 /* My reading of the SVR4 ABI indicates that the 1765 procedure linkage table relocs (DT_JMPREL) should be 1766 included in the overall relocs (DT_REL). This is 1767 what Solaris does. However, UnixWare can not handle 1768 that case. Therefore, we override the DT_RELSZ entry 1769 here to make it not include the JMPREL relocs. Since 1770 the linker script arranges for .rel.plt to follow all 1771 other relocation sections, we don't have to worry 1772 about changing the DT_REL entry. */ 1773 s = bfd_get_section_by_name (output_bfd, ".rel.plt"); 1774 if (s != NULL) 1775 { 1776 if (s->_cooked_size != 0) 1777 dyn.d_un.d_val -= s->_cooked_size; 1778 else 1779 dyn.d_un.d_val -= s->_raw_size; 1780 } 1781 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 1782 break; 1783 } 1784 } 1785 1786 /* Fill in the first entry in the procedure linkage table. */ 1787 if (splt->_raw_size > 0) 1788 { 1789 if (info->shared) 1790 memcpy (splt->contents, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE); 1791 else 1792 { 1793 memcpy (splt->contents, elf_i386_plt0_entry, PLT_ENTRY_SIZE); 1794 bfd_put_32 (output_bfd, 1795 sgot->output_section->vma + sgot->output_offset + 4, 1796 splt->contents + 2); 1797 bfd_put_32 (output_bfd, 1798 sgot->output_section->vma + sgot->output_offset + 8, 1799 splt->contents + 8); 1800 } 1801 } 1802 1803 /* UnixWare sets the entsize of .plt to 4, although that doesn't 1804 really seem like the right value. */ 1805 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4; 1806 } 1807 1808 /* Fill in the first three entries in the global offset table. */ 1809 if (sgot->_raw_size > 0) 1810 { 1811 if (sdyn == NULL) 1812 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); 1813 else 1814 bfd_put_32 (output_bfd, 1815 sdyn->output_section->vma + sdyn->output_offset, 1816 sgot->contents); 1817 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4); 1818 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8); 1819 } 1820 1821 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 1822 1823 return true; 1824} 1825 1826#define TARGET_LITTLE_SYM bfd_elf32_i386_vec 1827#define TARGET_LITTLE_NAME "elf32-i386" 1828#define ELF_ARCH bfd_arch_i386 1829#define ELF_MACHINE_CODE EM_386 1830#define ELF_MAXPAGESIZE 0x1000 1831#define elf_info_to_howto elf_i386_info_to_howto 1832#define elf_info_to_howto_rel elf_i386_info_to_howto_rel 1833#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup 1834#define bfd_elf32_bfd_is_local_label_name \ 1835 elf_i386_is_local_label_name 1836#define elf_backend_create_dynamic_sections \ 1837 _bfd_elf_create_dynamic_sections 1838#define bfd_elf32_bfd_link_hash_table_create \ 1839 elf_i386_link_hash_table_create 1840#define elf_backend_check_relocs elf_i386_check_relocs 1841#define elf_backend_adjust_dynamic_symbol \ 1842 elf_i386_adjust_dynamic_symbol 1843#define elf_backend_size_dynamic_sections \ 1844 elf_i386_size_dynamic_sections 1845#define elf_backend_relocate_section elf_i386_relocate_section 1846#define elf_backend_finish_dynamic_symbol \ 1847 elf_i386_finish_dynamic_symbol 1848#define elf_backend_finish_dynamic_sections \ 1849 elf_i386_finish_dynamic_sections 1850#define elf_backend_want_got_plt 1 1851#define elf_backend_plt_readonly 1 1852#define elf_backend_want_plt_sym 0 1853 1854#include "elf32-target.h" 1855