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