elflink.c revision 94536
1/* ELF linking support for BFD. 2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 3 Free Software Foundation, Inc. 4 5This file is part of BFD, the Binary File Descriptor library. 6 7This program is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2 of the License, or 10(at your option) any later version. 11 12This program is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with this program; if not, write to the Free Software 19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 21#include "bfd.h" 22#include "sysdep.h" 23#include "bfdlink.h" 24#include "libbfd.h" 25#define ARCH_SIZE 0 26#include "elf-bfd.h" 27 28boolean 29_bfd_elf_create_got_section (abfd, info) 30 bfd *abfd; 31 struct bfd_link_info *info; 32{ 33 flagword flags; 34 register asection *s; 35 struct elf_link_hash_entry *h; 36 struct elf_backend_data *bed = get_elf_backend_data (abfd); 37 int ptralign; 38 39 /* This function may be called more than once. */ 40 if (bfd_get_section_by_name (abfd, ".got") != NULL) 41 return true; 42 43 switch (bed->s->arch_size) 44 { 45 case 32: 46 ptralign = 2; 47 break; 48 49 case 64: 50 ptralign = 3; 51 break; 52 53 default: 54 bfd_set_error (bfd_error_bad_value); 55 return false; 56 } 57 58 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 59 | SEC_LINKER_CREATED); 60 61 s = bfd_make_section (abfd, ".got"); 62 if (s == NULL 63 || !bfd_set_section_flags (abfd, s, flags) 64 || !bfd_set_section_alignment (abfd, s, ptralign)) 65 return false; 66 67 if (bed->want_got_plt) 68 { 69 s = bfd_make_section (abfd, ".got.plt"); 70 if (s == NULL 71 || !bfd_set_section_flags (abfd, s, flags) 72 || !bfd_set_section_alignment (abfd, s, ptralign)) 73 return false; 74 } 75 76 if (bed->want_got_sym) 77 { 78 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got 79 (or .got.plt) section. We don't do this in the linker script 80 because we don't want to define the symbol if we are not creating 81 a global offset table. */ 82 h = NULL; 83 if (!(_bfd_generic_link_add_one_symbol 84 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s, 85 bed->got_symbol_offset, (const char *) NULL, false, 86 bed->collect, (struct bfd_link_hash_entry **) &h))) 87 return false; 88 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR; 89 h->type = STT_OBJECT; 90 91 if (info->shared 92 && ! _bfd_elf_link_record_dynamic_symbol (info, h)) 93 return false; 94 95 elf_hash_table (info)->hgot = h; 96 } 97 98 /* The first bit of the global offset table is the header. */ 99 s->_raw_size += bed->got_header_size + bed->got_symbol_offset; 100 101 return true; 102} 103 104/* Create dynamic sections when linking against a dynamic object. */ 105 106boolean 107_bfd_elf_create_dynamic_sections (abfd, info) 108 bfd *abfd; 109 struct bfd_link_info *info; 110{ 111 flagword flags, pltflags; 112 register asection *s; 113 struct elf_backend_data *bed = get_elf_backend_data (abfd); 114 int ptralign; 115 116 switch (bed->s->arch_size) 117 { 118 case 32: 119 ptralign = 2; 120 break; 121 122 case 64: 123 ptralign = 3; 124 break; 125 126 default: 127 bfd_set_error (bfd_error_bad_value); 128 return false; 129 } 130 131 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and 132 .rel[a].bss sections. */ 133 134 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 135 | SEC_LINKER_CREATED); 136 137 pltflags = flags; 138 pltflags |= SEC_CODE; 139 if (bed->plt_not_loaded) 140 pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS); 141 if (bed->plt_readonly) 142 pltflags |= SEC_READONLY; 143 144 s = bfd_make_section (abfd, ".plt"); 145 if (s == NULL 146 || ! bfd_set_section_flags (abfd, s, pltflags) 147 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment)) 148 return false; 149 150 if (bed->want_plt_sym) 151 { 152 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the 153 .plt section. */ 154 struct elf_link_hash_entry *h = NULL; 155 if (! (_bfd_generic_link_add_one_symbol 156 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 157 (bfd_vma) 0, (const char *) NULL, false, 158 get_elf_backend_data (abfd)->collect, 159 (struct bfd_link_hash_entry **) &h))) 160 return false; 161 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR; 162 h->type = STT_OBJECT; 163 164 if (info->shared 165 && ! _bfd_elf_link_record_dynamic_symbol (info, h)) 166 return false; 167 } 168 169 s = bfd_make_section (abfd, 170 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt"); 171 if (s == NULL 172 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY) 173 || ! bfd_set_section_alignment (abfd, s, ptralign)) 174 return false; 175 176 if (! _bfd_elf_create_got_section (abfd, info)) 177 return false; 178 179 if (bed->want_dynbss) 180 { 181 /* The .dynbss section is a place to put symbols which are defined 182 by dynamic objects, are referenced by regular objects, and are 183 not functions. We must allocate space for them in the process 184 image and use a R_*_COPY reloc to tell the dynamic linker to 185 initialize them at run time. The linker script puts the .dynbss 186 section into the .bss section of the final image. */ 187 s = bfd_make_section (abfd, ".dynbss"); 188 if (s == NULL 189 || ! bfd_set_section_flags (abfd, s, SEC_ALLOC)) 190 return false; 191 192 /* The .rel[a].bss section holds copy relocs. This section is not 193 normally needed. We need to create it here, though, so that the 194 linker will map it to an output section. We can't just create it 195 only if we need it, because we will not know whether we need it 196 until we have seen all the input files, and the first time the 197 main linker code calls BFD after examining all the input files 198 (size_dynamic_sections) the input sections have already been 199 mapped to the output sections. If the section turns out not to 200 be needed, we can discard it later. We will never need this 201 section when generating a shared object, since they do not use 202 copy relocs. */ 203 if (! info->shared) 204 { 205 s = bfd_make_section (abfd, 206 (bed->default_use_rela_p 207 ? ".rela.bss" : ".rel.bss")); 208 if (s == NULL 209 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY) 210 || ! bfd_set_section_alignment (abfd, s, ptralign)) 211 return false; 212 } 213 } 214 215 return true; 216} 217 218/* Record a new dynamic symbol. We record the dynamic symbols as we 219 read the input files, since we need to have a list of all of them 220 before we can determine the final sizes of the output sections. 221 Note that we may actually call this function even though we are not 222 going to output any dynamic symbols; in some cases we know that a 223 symbol should be in the dynamic symbol table, but only if there is 224 one. */ 225 226boolean 227_bfd_elf_link_record_dynamic_symbol (info, h) 228 struct bfd_link_info *info; 229 struct elf_link_hash_entry *h; 230{ 231 if (h->dynindx == -1) 232 { 233 struct elf_strtab_hash *dynstr; 234 char *p, *alc; 235 const char *name; 236 boolean copy; 237 bfd_size_type indx; 238 239 /* XXX: The ABI draft says the linker must turn hidden and 240 internal symbols into STB_LOCAL symbols when producing the 241 DSO. However, if ld.so honors st_other in the dynamic table, 242 this would not be necessary. */ 243 switch (ELF_ST_VISIBILITY (h->other)) 244 { 245 case STV_INTERNAL: 246 case STV_HIDDEN: 247 if (h->root.type != bfd_link_hash_undefined 248 && h->root.type != bfd_link_hash_undefweak) 249 { 250 h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL; 251 return true; 252 } 253 254 default: 255 break; 256 } 257 258 h->dynindx = elf_hash_table (info)->dynsymcount; 259 ++elf_hash_table (info)->dynsymcount; 260 261 dynstr = elf_hash_table (info)->dynstr; 262 if (dynstr == NULL) 263 { 264 /* Create a strtab to hold the dynamic symbol names. */ 265 elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init (); 266 if (dynstr == NULL) 267 return false; 268 } 269 270 /* We don't put any version information in the dynamic string 271 table. */ 272 name = h->root.root.string; 273 p = strchr (name, ELF_VER_CHR); 274 if (p == NULL) 275 { 276 alc = NULL; 277 copy = false; 278 } 279 else 280 { 281 alc = bfd_malloc ((bfd_size_type) (p - name + 1)); 282 if (alc == NULL) 283 return false; 284 strncpy (alc, name, (size_t) (p - name)); 285 alc[p - name] = '\0'; 286 name = alc; 287 copy = true; 288 } 289 290 indx = _bfd_elf_strtab_add (dynstr, name, copy); 291 292 if (alc != NULL) 293 free (alc); 294 295 if (indx == (bfd_size_type) -1) 296 return false; 297 h->dynstr_index = indx; 298 } 299 300 return true; 301} 302 303/* Return the dynindex of a local dynamic symbol. */ 304 305long 306_bfd_elf_link_lookup_local_dynindx (info, input_bfd, input_indx) 307 struct bfd_link_info *info; 308 bfd *input_bfd; 309 long input_indx; 310{ 311 struct elf_link_local_dynamic_entry *e; 312 313 for (e = elf_hash_table (info)->dynlocal; e ; e = e->next) 314 if (e->input_bfd == input_bfd && e->input_indx == input_indx) 315 return e->dynindx; 316 return -1; 317} 318 319/* This function is used to renumber the dynamic symbols, if some of 320 them are removed because they are marked as local. This is called 321 via elf_link_hash_traverse. */ 322 323static boolean elf_link_renumber_hash_table_dynsyms 324 PARAMS ((struct elf_link_hash_entry *, PTR)); 325 326static boolean 327elf_link_renumber_hash_table_dynsyms (h, data) 328 struct elf_link_hash_entry *h; 329 PTR data; 330{ 331 size_t *count = (size_t *) data; 332 333 if (h->root.type == bfd_link_hash_warning) 334 h = (struct elf_link_hash_entry *) h->root.u.i.link; 335 336 if (h->dynindx != -1) 337 h->dynindx = ++(*count); 338 339 return true; 340} 341 342/* Assign dynsym indices. In a shared library we generate a section 343 symbol for each output section, which come first. Next come all of 344 the back-end allocated local dynamic syms, followed by the rest of 345 the global symbols. */ 346 347unsigned long 348_bfd_elf_link_renumber_dynsyms (output_bfd, info) 349 bfd *output_bfd; 350 struct bfd_link_info *info; 351{ 352 unsigned long dynsymcount = 0; 353 354 if (info->shared) 355 { 356 asection *p; 357 for (p = output_bfd->sections; p ; p = p->next) 358 elf_section_data (p)->dynindx = ++dynsymcount; 359 } 360 361 if (elf_hash_table (info)->dynlocal) 362 { 363 struct elf_link_local_dynamic_entry *p; 364 for (p = elf_hash_table (info)->dynlocal; p ; p = p->next) 365 p->dynindx = ++dynsymcount; 366 } 367 368 elf_link_hash_traverse (elf_hash_table (info), 369 elf_link_renumber_hash_table_dynsyms, 370 &dynsymcount); 371 372 /* There is an unused NULL entry at the head of the table which 373 we must account for in our count. Unless there weren't any 374 symbols, which means we'll have no table at all. */ 375 if (dynsymcount != 0) 376 ++dynsymcount; 377 378 return elf_hash_table (info)->dynsymcount = dynsymcount; 379} 380 381/* Create a special linker section, or return a pointer to a linker 382 section already created */ 383 384elf_linker_section_t * 385_bfd_elf_create_linker_section (abfd, info, which, defaults) 386 bfd *abfd; 387 struct bfd_link_info *info; 388 enum elf_linker_section_enum which; 389 elf_linker_section_t *defaults; 390{ 391 bfd *dynobj = elf_hash_table (info)->dynobj; 392 elf_linker_section_t *lsect; 393 394 /* Record the first bfd section that needs the special section */ 395 if (!dynobj) 396 dynobj = elf_hash_table (info)->dynobj = abfd; 397 398 /* If this is the first time, create the section */ 399 lsect = elf_linker_section (dynobj, which); 400 if (!lsect) 401 { 402 asection *s; 403 bfd_size_type amt = sizeof (elf_linker_section_t); 404 405 lsect = (elf_linker_section_t *) bfd_alloc (dynobj, amt); 406 407 *lsect = *defaults; 408 elf_linker_section (dynobj, which) = lsect; 409 lsect->which = which; 410 lsect->hole_written_p = false; 411 412 /* See if the sections already exist */ 413 lsect->section = s = bfd_get_section_by_name (dynobj, lsect->name); 414 if (!s || (s->flags & defaults->flags) != defaults->flags) 415 { 416 lsect->section = s = bfd_make_section_anyway (dynobj, lsect->name); 417 418 if (s == NULL) 419 return (elf_linker_section_t *)0; 420 421 bfd_set_section_flags (dynobj, s, defaults->flags); 422 bfd_set_section_alignment (dynobj, s, lsect->alignment); 423 } 424 else if (bfd_get_section_alignment (dynobj, s) < lsect->alignment) 425 bfd_set_section_alignment (dynobj, s, lsect->alignment); 426 427 s->_raw_size = align_power (s->_raw_size, lsect->alignment); 428 429 /* Is there a hole we have to provide? If so check whether the segment is 430 too big already */ 431 if (lsect->hole_size) 432 { 433 lsect->hole_offset = s->_raw_size; 434 s->_raw_size += lsect->hole_size; 435 if (lsect->hole_offset > lsect->max_hole_offset) 436 { 437 (*_bfd_error_handler) (_("%s: Section %s is too large to add hole of %ld bytes"), 438 bfd_get_filename (abfd), 439 lsect->name, 440 (long) lsect->hole_size); 441 442 bfd_set_error (bfd_error_bad_value); 443 return (elf_linker_section_t *)0; 444 } 445 } 446 447#ifdef DEBUG 448 fprintf (stderr, "Creating section %s, current size = %ld\n", 449 lsect->name, (long)s->_raw_size); 450#endif 451 452 if (lsect->sym_name) 453 { 454 struct elf_link_hash_entry *h = NULL; 455#ifdef DEBUG 456 fprintf (stderr, "Adding %s to section %s\n", 457 lsect->sym_name, 458 lsect->name); 459#endif 460 h = (struct elf_link_hash_entry *) 461 bfd_link_hash_lookup (info->hash, lsect->sym_name, false, false, false); 462 463 if ((h == NULL || h->root.type == bfd_link_hash_undefined) 464 && !(_bfd_generic_link_add_one_symbol (info, 465 abfd, 466 lsect->sym_name, 467 BSF_GLOBAL, 468 s, 469 ((lsect->hole_size) 470 ? s->_raw_size - lsect->hole_size + lsect->sym_offset 471 : lsect->sym_offset), 472 (const char *) NULL, 473 false, 474 get_elf_backend_data (abfd)->collect, 475 (struct bfd_link_hash_entry **) &h))) 476 return (elf_linker_section_t *)0; 477 478 if ((defaults->which != LINKER_SECTION_SDATA) 479 && (defaults->which != LINKER_SECTION_SDATA2)) 480 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_DYNAMIC; 481 482 h->type = STT_OBJECT; 483 lsect->sym_hash = h; 484 485 if (info->shared 486 && ! _bfd_elf_link_record_dynamic_symbol (info, h)) 487 return (elf_linker_section_t *)0; 488 } 489 } 490 491#if 0 492 /* This does not make sense. The sections which may exist in the 493 object file have nothing to do with the sections we want to 494 create. */ 495 496 /* Find the related sections if they have been created */ 497 if (lsect->bss_name && !lsect->bss_section) 498 lsect->bss_section = bfd_get_section_by_name (dynobj, lsect->bss_name); 499 500 if (lsect->rel_name && !lsect->rel_section) 501 lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name); 502#endif 503 504 return lsect; 505} 506 507/* Find a linker generated pointer with a given addend and type. */ 508 509elf_linker_section_pointers_t * 510_bfd_elf_find_pointer_linker_section (linker_pointers, addend, which) 511 elf_linker_section_pointers_t *linker_pointers; 512 bfd_vma addend; 513 elf_linker_section_enum_t which; 514{ 515 for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next) 516 { 517 if (which == linker_pointers->which && addend == linker_pointers->addend) 518 return linker_pointers; 519 } 520 521 return (elf_linker_section_pointers_t *)0; 522} 523 524/* Make the .rela section corresponding to the generated linker section. */ 525 526boolean 527_bfd_elf_make_linker_section_rela (dynobj, lsect, alignment) 528 bfd *dynobj; 529 elf_linker_section_t *lsect; 530 int alignment; 531{ 532 if (lsect->rel_section) 533 return true; 534 535 lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name); 536 if (lsect->rel_section == NULL) 537 { 538 lsect->rel_section = bfd_make_section (dynobj, lsect->rel_name); 539 if (lsect->rel_section == NULL 540 || ! bfd_set_section_flags (dynobj, 541 lsect->rel_section, 542 (SEC_ALLOC 543 | SEC_LOAD 544 | SEC_HAS_CONTENTS 545 | SEC_IN_MEMORY 546 | SEC_LINKER_CREATED 547 | SEC_READONLY)) 548 || ! bfd_set_section_alignment (dynobj, lsect->rel_section, alignment)) 549 return false; 550 } 551 552 return true; 553} 554