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