1/* Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 Red Hat, Inc. 2 This file is part of Red Hat elfutils. 3 Written by Ulrich Drepper <drepper@redhat.com>, 2001. 4 5 Red Hat elfutils is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by the 7 Free Software Foundation; version 2 of the License. 8 9 Red Hat elfutils is distributed in the hope that it will be useful, but 10 WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 General Public License for more details. 13 14 You should have received a copy of the GNU General Public License along 15 with Red Hat elfutils; if not, write to the Free Software Foundation, 16 Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA. 17 18 Red Hat elfutils is an included package of the Open Invention Network. 19 An included package of the Open Invention Network is a package for which 20 Open Invention Network licensees cross-license their patents. No patent 21 license is granted, either expressly or impliedly, by designation as an 22 included package. Should you wish to participate in the Open Invention 23 Network licensing program, please visit www.openinventionnetwork.com 24 <http://www.openinventionnetwork.com>. */ 25 26#ifdef HAVE_CONFIG_H 27# include <config.h> 28#endif 29 30#include <argp.h> 31#include <assert.h> 32#include <error.h> 33#include <fcntl.h> 34#include <libelf.h> 35#include <libintl.h> 36#include <locale.h> 37#include <mcheck.h> 38#include <stdio.h> 39#include <stdio_ext.h> 40#include <stdlib.h> 41#include <string.h> 42#include <unistd.h> 43 44#include <system.h> 45#include "ld.h" 46#include "list.h" 47 48 49/* Name and version of program. */ 50static void print_version (FILE *stream, struct argp_state *state); 51void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version; 52 53/* Bug report address. */ 54const char *argp_program_bug_address = PACKAGE_BUGREPORT; 55 56 57/* Values for the various options. */ 58enum 59 { 60 ARGP_whole_archive = 300, 61 ARGP_no_whole_archive, 62 ARGP_static, 63 ARGP_dynamic, 64 ARGP_pagesize, 65 ARGP_rpath_link, 66 ARGP_runpath, 67 ARGP_runpath_link, 68 ARGP_version_script, 69 ARGP_gc_sections, 70 ARGP_no_gc_sections, 71 ARGP_no_undefined, 72 ARGP_conserve, 73 ARGP_as_needed, 74 ARGP_no_as_needed, 75 ARGP_eh_frame_hdr, 76 ARGP_hash_style, 77 ARGP_build_id, 78#if YYDEBUG 79 ARGP_yydebug, 80#endif 81 }; 82 83 84/* Definitions of arguments for argp functions. */ 85static const struct argp_option options[] = 86{ 87 { NULL, 0, NULL, 0, N_("Input File Control:"), 0 }, 88 { "whole-archive", ARGP_whole_archive, NULL, 0, 89 N_("Include whole archives in the output from now on."), 0 }, 90 { "no-whole-archive", ARGP_no_whole_archive, NULL, 0, 91 N_("Stop including the whole arhives in the output."), 0 }, 92 { NULL, 'l', N_("FILE"), OPTION_HIDDEN, NULL, 0 }, 93 { "start-group", '(', NULL, 0, N_("Start a group."), 0 }, 94 { "end-group", ')', NULL, 0, N_("End a group."), 0 }, 95 { NULL, 'L', N_("PATH"), 0, 96 N_("Add PATH to list of directories files are searched in."), 0 }, 97 { "as-needed", ARGP_as_needed, NULL, 0, 98 N_("Only set DT_NEEDED for following dynamic libs if actually used"), 0 }, 99 { "no-as-needed", ARGP_no_as_needed, NULL, 0, 100 N_("Always set DT_NEEDED for following dynamic libs"), 0 }, 101 { "rpath-link", ARGP_rpath_link, "PATH", OPTION_HIDDEN, NULL, 0 }, 102 { NULL, 'i', NULL, 0, N_("Ignore LD_LIBRARY_PATH environment variable."), 103 0 }, 104 105 { NULL, 0, NULL, 0, N_("Output File Control:"), 0 }, 106 { "output", 'o', N_("FILE"), 0, N_("Place output in FILE."), 0 }, 107 { NULL, 'z', "KEYWORD", OPTION_HIDDEN, NULL, 0 }, 108 { "-z nodefaultlib", '\0', NULL, OPTION_DOC, 109 N_("Object is marked to not use default search path at runtime."), 0 }, 110 { "-z allextract", '\0', NULL, OPTION_DOC, 111 N_("Same as --whole-archive."), 0 }, 112 { "-z defaultextract", '\0', NULL, OPTION_DOC, N_("\ 113Default rules of extracting from archive; weak references are not enough."), 114 0 }, 115 { "-z weakextract", '\0', NULL, OPTION_DOC, 116 N_("Weak references cause extraction from archive."), 0 }, 117 { "-z muldefs", '\0', NULL, OPTION_DOC, 118 N_("Allow multiple definitions; first is used."), 0 }, 119 { "-z defs | nodefs", '\0', NULL, OPTION_DOC, 120 N_("Disallow/allow undefined symbols in DSOs."), 0 }, 121 { "no-undefined", ARGP_no_undefined, NULL, OPTION_HIDDEN, NULL, 0 }, 122 { "-z origin", '\0', NULL, OPTION_DOC, 123 N_("Object requires immediate handling of $ORIGIN."), 0 }, 124 { "-z now", '\0', NULL, OPTION_DOC, 125 N_("Relocation will not be processed lazily."), 0 }, 126 { "-z nodelete", '\0', NULL, OPTION_DOC, 127 N_("Object cannot be unloaded at runtime."), 0 }, 128 { "-z initfirst", '\0', NULL, OPTION_DOC, 129 N_("Mark object to be initialized first."), 0 }, 130 { "-z lazyload | nolazyload", '\0', NULL, OPTION_DOC, 131 N_("Enable/disable lazy-loading flag for following dependencies."), 0 }, 132 { "-z nodlopen", '\0', NULL, OPTION_DOC, 133 N_("Mark object as not loadable with 'dlopen'."), 0 }, 134 { "-z ignore | record", '\0', NULL, OPTION_DOC, 135 N_("Ignore/record dependencies on unused DSOs."), 0 }, 136 { "-z systemlibrary", '\0', NULL, OPTION_DOC, 137 N_("Generated DSO will be a system library."), 0 }, 138 { "entry", 'e', N_("ADDRESS"), 0, N_("Set entry point address."), 0 }, 139 { "static", ARGP_static, NULL, OPTION_HIDDEN, NULL, 0 }, 140 { "-B static", ARGP_static, NULL, OPTION_DOC, 141 N_("Do not link against shared libraries."), 0 }, 142 { "dynamic", ARGP_dynamic, NULL, OPTION_HIDDEN, NULL, 0 }, 143 { "-B dynamic", ARGP_dynamic, NULL, OPTION_DOC, 144 N_("Prefer linking against shared libraries."), 0 }, 145 { "export-dynamic", 'E', NULL, 0, N_("Export all dynamic symbols."), 0 }, 146 { "strip-all", 's', NULL, 0, N_("Strip all symbols."), 0 }, 147 { "strip-debug", 'S', NULL, 0, N_("Strip debugging symbols."), 0 }, 148 { "pagesize", ARGP_pagesize, "SIZE", 0, 149 N_("Assume pagesize for the target system to be SIZE."), 0 }, 150 { "rpath", 'R', "PATH", OPTION_HIDDEN, NULL, 0 }, 151 { "runpath", ARGP_runpath, "PATH", 0, N_("Set runtime DSO search path."), 152 0 }, 153 { "runpath-link", ARGP_runpath_link, "PATH", 0, 154 N_("Set link time DSO search path."), 0 }, 155 { "shared", 'G', NULL, 0, N_("Generate dynamic shared object."), 0 }, 156 { NULL, 'r', NULL, 0L, N_("Generate relocatable object."), 0 }, 157 { NULL, 'B', "KEYWORD", OPTION_HIDDEN, "", 0 }, 158 { "-B local", 'B', NULL, OPTION_DOC, 159 N_("Causes symbol not assigned to a version be reduced to local."), 0 }, 160 { "gc-sections", ARGP_gc_sections, NULL, 0, N_("Remove unused sections."), 161 0 }, 162 { "no-gc-sections", ARGP_no_gc_sections, NULL, 0, 163 N_("Don't remove unused sections."), 0 }, 164 { "soname", 'h', "NAME", 0, N_("Set soname of shared object."), 0 }, 165 { "dynamic-linker", 'I', "NAME", 0, N_("Set the dynamic linker name."), 0 }, 166 { NULL, 'Q', "YN", OPTION_HIDDEN, NULL, 0 }, 167 { "-Q y | n", 'Q', NULL, OPTION_DOC, 168 N_("Add/suppress addition indentifying link-editor to .comment section."), 169 0 }, 170 { "eh-frame-hdr", ARGP_eh_frame_hdr, NULL, 0, 171 N_("Create .eh_frame_hdr section"), 0 }, 172 { "hash-style", ARGP_hash_style, "STYLE", 0, 173 N_("Set hash style to sysv, gnu or both."), 0 }, 174 { "build-id", ARGP_build_id, "STYLE", OPTION_ARG_OPTIONAL, 175 N_("Generate build ID note (md5, sha1 (default), uuid)."), 0 }, 176 177 { NULL, 0, NULL, 0, N_("Linker Operation Control:"), 0 }, 178 { "verbose", 'v', NULL, 0, N_("Verbose messages."), 0 }, 179 { "trace", 't', NULL, 0, N_("Trace file opens."), 0 }, 180 { "conserve-memory", ARGP_conserve, NULL, 0, 181 N_("Trade speed for less memory usage"), 0 }, 182 { NULL, 'O', N_("LEVEL"), OPTION_ARG_OPTIONAL, 183 N_("Set optimization level to LEVEL."), 0 }, 184 { NULL, 'c', N_("FILE"), 0, N_("Use linker script in FILE."), 0 }, 185#if YYDEBUG 186 { "yydebug", ARGP_yydebug, NULL, 0, 187 N_("Select to get parser debug information"), 0 }, 188#endif 189 { "version-script", ARGP_version_script, "FILE", 0, 190 N_("Read version information from FILE."), 0 }, 191 { "emulation", 'm', "NAME", 0, N_("Set emulation to NAME."), 0 }, 192 193 { NULL, 0, NULL, 0, NULL, 0 } 194}; 195 196/* Short description of program. */ 197static const char doc[] = N_("Combine object and archive files."); 198 199/* Strings for arguments in help texts. */ 200static const char args_doc[] = N_("[FILE]..."); 201 202/* Prototype for option handler. */ 203static void replace_args (int argc, char *argv[]); 204static error_t parse_opt_1st (int key, char *arg, struct argp_state *state); 205static error_t parse_opt_2nd (int key, char *arg, struct argp_state *state); 206 207/* Data structure to communicate with argp functions. */ 208static struct argp argp_1st = 209{ 210 options, parse_opt_1st, args_doc, doc, NULL, NULL, NULL 211}; 212static struct argp argp_2nd = 213{ 214 options, parse_opt_2nd, args_doc, doc, NULL, NULL, NULL 215}; 216 217 218/* Linker state. This contains all global information. */ 219struct ld_state ld_state; 220 221/* List of the input files. */ 222static struct file_list 223{ 224 const char *name; 225 struct file_list *next; 226} *input_file_list; 227 228/* If nonzero be verbose. */ 229int verbose; 230 231/* If nonzero, trade speed for less memory/address space usage. */ 232int conserve_memory; 233 234/* The emulation name to use. */ 235static const char *emulation; 236 237/* Keep track of the nesting level. Even though we don't handle nested 238 groups we still keep track to improve the error messages. */ 239static int group_level; 240 241/* The last file we processed. */ 242static struct usedfiles *last_file; 243 244/* The default linker script. */ 245/* XXX We'll do this a bit different in the real solution. */ 246static const char *linker_script = SRCDIR "/elf32-i386.script"; 247 248/* Nonzero if an error occurred while loading the input files. */ 249static int error_loading; 250 251 252/* Intermediate storage for the LD_LIBRARY_PATH information from the 253 environment. */ 254static char *ld_library_path1; 255 256/* Flag used to communicate with the scanner. */ 257int ld_scan_version_script; 258 259/* Name of the input file. */ 260const char *ldin_fname; 261 262/* Define by parser if required. */ 263extern int lddebug; 264 265 266/* Prototypes for local functions. */ 267static void parse_z_option (const char *arg); 268static void parse_z_option_2 (const char *arg); 269static void parse_B_option (const char *arg); 270static void parse_B_option_2 (const char *arg); 271static void determine_output_format (void); 272static void load_needed (void); 273static void collect_sections (void); 274static void add_rxxpath (struct pathelement **pathp, const char *str); 275static void gen_rxxpath_data (void); 276static void read_version_script (const char *fname); 277static void create_lscript_symbols (void); 278static void create_special_section_symbol (struct symbol **symp, 279 const char *name); 280 281 282int 283main (int argc, char *argv[]) 284{ 285 int remaining; 286 int err; 287 288#ifndef NDEBUG 289 /* Enable memory debugging. */ 290 mtrace (); 291#endif 292 293 /* Sanity check. We always want to use the LFS functionality. */ 294 if (sizeof (off_t) != sizeof (off64_t)) 295 abort (); 296 297 /* We use no threads here which can interfere with handling a stream. */ 298 __fsetlocking (stdin, FSETLOCKING_BYCALLER); 299 __fsetlocking (stdout, FSETLOCKING_BYCALLER); 300 __fsetlocking (stderr, FSETLOCKING_BYCALLER); 301 302 /* Set locale. */ 303 setlocale (LC_ALL, ""); 304 305 /* Make sure the message catalog can be found. */ 306 bindtextdomain (PACKAGE_TARNAME, LOCALEDIR); 307 308 /* Initialize the message catalog. */ 309 textdomain (PACKAGE_TARNAME); 310 311 /* Before we start tell the ELF library which version we are using. */ 312 elf_version (EV_CURRENT); 313 314 /* The user can use the LD_LIBRARY_PATH environment variable to add 315 additional lookup directories. */ 316 ld_library_path1 = getenv ("LD_LIBRARY_PATH"); 317 318 /* Initialize the memory handling. */ 319#define obstack_chunk_alloc xmalloc 320#define obstack_chunk_free free 321 obstack_init (&ld_state.smem); 322 323 /* Recognize old-style parameters for compatibility. */ 324 replace_args (argc, argv); 325 326 /* One quick pass over the parameters which allows us to scan for options 327 with global effect which influence the rest of the processing. */ 328 argp_parse (&argp_1st, argc, argv, ARGP_IN_ORDER, &remaining, NULL); 329 330 /* We need at least one input file. */ 331 if (input_file_list == NULL) 332 { 333 error (0, 0, gettext ("At least one input file needed")); 334 argp_help (&argp_1st, stderr, ARGP_HELP_SEE, "ld"); 335 exit (EXIT_FAILURE); 336 } 337 338 /* Determine which ELF backend to use. */ 339 determine_output_format (); 340 341 /* If no hash style was specific default to the oldand slow SysV 342 method. */ 343 if (unlikely (ld_state.hash_style == hash_style_none)) 344 ld_state.hash_style = hash_style_sysv; 345 346 /* Prepare state. */ 347 err = ld_prepare_state (emulation); 348 if (err != 0) 349 error (EXIT_FAILURE, 0, gettext ("error while preparing linking")); 350 351 /* XXX Read the linker script now. Since we later will have the linker 352 script built in we don't go into trouble to make sure we handle GROUP 353 statements in the script. This simply must not happen. */ 354 ldin = fopen (linker_script, "r"); 355 if (ldin == NULL) 356 error (EXIT_FAILURE, errno, gettext ("cannot open linker script '%s'"), 357 linker_script); 358 /* No need for locking. */ 359 __fsetlocking (ldin, FSETLOCKING_BYCALLER); 360 361 ld_state.srcfiles = NULL; 362 ldlineno = 1; 363 ld_scan_version_script = 0; 364 ldin_fname = linker_script; 365 if (ldparse () != 0) 366 /* Something went wrong during parsing. */ 367 exit (EXIT_FAILURE); 368 fclose (ldin); 369 370 /* We now might have a list of directories to look for libraries in 371 named by the linker script. Put them in a different list so that 372 they are searched after all paths given by the user on the 373 command line. */ 374 ld_state.default_paths = ld_state.paths; 375 ld_state.paths = ld_state.tailpaths = NULL; 376 377 /* Get runpath/rpath information in usable form. */ 378 gen_rxxpath_data (); 379 380 /* Parse and process arguments for real. */ 381 argp_parse (&argp_2nd, argc, argv, ARGP_IN_ORDER, &remaining, NULL); 382 /* All options should have been processed by the argp parser. */ 383 assert (remaining == argc); 384 385 /* Process the last file. */ 386 while (last_file != NULL) 387 /* Try to open the file. */ 388 error_loading |= FILE_PROCESS (-1, last_file, &ld_state, &last_file); 389 390 /* Stop if there has been a problem while reading the input files. */ 391 if (error_loading) 392 exit (error_loading); 393 394 /* See whether all opened -( were closed. */ 395 if (group_level > 0) 396 { 397 error (0, 0, gettext ("-( without matching -)")); 398 argp_help (&argp_1st, stderr, ARGP_HELP_SEE, "ld"); 399 exit (EXIT_FAILURE); 400 } 401 402 /* When we create a relocatable file we don't have to look for the 403 DT_NEEDED DSOs and we also don't test for undefined symbols. */ 404 if (ld_state.file_type != relocatable_file_type) 405 { 406 /* At this point we have loaded all the direct dependencies. What 407 remains to be done is find the indirect dependencies. These are 408 DSOs which are referenced by the DT_NEEDED entries in the DSOs 409 which are direct dependencies. We have to transitively find and 410 load all these dependencies. */ 411 load_needed (); 412 413 /* At this point all object files and DSOs are read. If there 414 are still undefined symbols left they might have to be 415 synthesized from the linker script. */ 416 create_lscript_symbols (); 417 418 /* Now that we have loaded all the object files we can determine 419 whether we have any non-weak unresolved references left. If 420 there are any we stop. If the user used the '-z nodefs' option 421 and we are creating a DSO don't perform the tests. */ 422 if (FLAG_UNRESOLVED (&ld_state) != 0) 423 exit (1); 424 } 425 426 /* Collect information about the relocations which will be carried 427 forward into the output. We have to do this here and now since 428 we need to know which sections have to be created. */ 429 if (ld_state.file_type != relocatable_file_type) 430 { 431 void *p ; 432 struct scnhead *h; 433 434 p = NULL; 435 while ((h = ld_section_tab_iterate (&ld_state.section_tab, &p)) != NULL) 436 if (h->type == SHT_REL || h->type == SHT_RELA) 437 { 438 struct scninfo *runp = h->last; 439 do 440 { 441 /* If we are processing the relocations determine how 442 many will be in the output file. Also determine 443 how many GOT entries are needed. */ 444 COUNT_RELOCATIONS (&ld_state, runp); 445 446 ld_state.relsize_total += runp->relsize; 447 } 448 while ((runp = runp->next) != h->last); 449 } 450 } 451 452 /* Not part of the gABI, but part of every psABI: the symbols for the 453 GOT section. Add the symbol if necessary. */ 454 if (ld_state.need_got) 455 create_special_section_symbol (&ld_state.got_symbol, 456 "_GLOBAL_OFFSET_TABLE_"); 457 /* Similarly for the _DYNAMIC symbol which points to the dynamic 458 section. */ 459 if (dynamically_linked_p ()) 460 create_special_section_symbol (&ld_state.dyn_symbol, "_DYNAMIC"); 461 462 /* We are ready to start working on the output file. Not all 463 information has been gather or created yet. This will be done as 464 we go. Open the file now. */ 465 if (OPEN_OUTFILE (&ld_state, EM_NONE, ELFCLASSNONE, ELFDATANONE) != 0) 466 exit (1); 467 468 /* Create the sections which are generated by the linker and are not 469 present in the input file. The output file must already have 470 been opened since we need the ELF descriptor to deduce type 471 sizes. */ 472 GENERATE_SECTIONS (&ld_state); 473 474 /* At this point we have read all the files and know all the 475 sections which have to be linked into the application. We do now 476 create an array listing all the sections. We will than pass this 477 array to a system specific function which can reorder it at will. 478 The functions can also merge sections if this is what is 479 wanted. */ 480 collect_sections (); 481 482 /* Create the output sections now. This may requires sorting them 483 first. */ 484 CREATE_SECTIONS (&ld_state); 485 486 /* Create the output file data. Appropriate code for the selected 487 output file type is called. */ 488 if (CREATE_OUTFILE (&ld_state) != 0) 489 exit (1); 490 491 /* Finalize the output file, write the data out. */ 492 err |= FINALIZE (&ld_state); 493 494 /* Return with an non-zero exit status also if any error message has 495 been printed. */ 496 return err | (error_message_count != 0); 497} 498 499 500static void 501replace_args (int argc, char *argv[]) 502{ 503 static const struct 504 { 505 const char *from; 506 const char *to; 507 } args[] = 508 { 509 { "-export-dynamic", "--export-dynamic" }, 510 { "-dynamic-linker", "--dynamic-linker" }, 511 { "-static", "--static" }, 512 }; 513 const size_t nargs = sizeof (args) / sizeof (args[0]); 514 515 for (int i = 1; i < argc; ++i) 516 if (argv[i][0] == '-' && islower (argv[i][1]) && argv[i][2] != '\0') 517 for (size_t j = 0; j < nargs; ++j) 518 if (strcmp (argv[i], args[j].from) == 0) 519 { 520 argv[i] = (char *) args[j].to; 521 break; 522 } 523} 524 525 526static int 527valid_hexarg (const char *arg) 528{ 529 if (strncasecmp (arg, "0x", 2) != 0) 530 return 0; 531 532 arg += 2; 533 do 534 { 535 if (isxdigit (arg[0]) && isxdigit (arg[1])) 536 { 537 arg += 2; 538 if (arg[0] == '-' || arg[0] == ':') 539 ++arg; 540 } 541 else 542 return 0; 543 } 544 while (*arg != '\0'); 545 546 return 1; 547} 548 549 550/* Quick scan of the parameter list for options with global effect. */ 551static error_t 552parse_opt_1st (int key, char *arg, 553 struct argp_state *state __attribute__ ((unused))) 554{ 555 switch (key) 556 { 557 case 'B': 558 parse_B_option (arg); 559 break; 560 561 case 'c': 562 linker_script = arg; 563 break; 564 565 case 'E': 566 ld_state.export_all_dynamic = true; 567 break; 568 569 case 'G': 570 if (ld_state.file_type != no_file_type) 571 error (EXIT_FAILURE, 0, 572 gettext ("only one option of -G and -r is allowed")); 573 ld_state.file_type = dso_file_type; 574 575 /* If we generate a DSO we have to export all symbols. */ 576 ld_state.export_all_dynamic = true; 577 break; 578 579 case 'h': 580 ld_state.soname = arg; 581 break; 582 583 case 'i': 584 /* Discard the LD_LIBRARY_PATH value we found. */ 585 ld_library_path1 = NULL; 586 break; 587 588 case 'I': 589 ld_state.interp = arg; 590 break; 591 592 case 'm': 593 if (emulation != NULL) 594 error (EXIT_FAILURE, 0, gettext ("more than one '-m' parameter")); 595 emulation = arg; 596 break; 597 598 case 'Q': 599 if (arg[1] == '\0' && (arg[0] == 'y' || arg[0] == 'Y')) 600 ld_state.add_ld_comment = true; 601 else if (arg[1] == '\0' && (arg[0] == 'n' || arg[0] == 'N')) 602 ld_state.add_ld_comment = true; 603 else 604 error (EXIT_FAILURE, 0, gettext ("unknown option `-%c %s'"), 'Q', arg); 605 break; 606 607 case 'r': 608 if (ld_state.file_type != no_file_type) 609 error (EXIT_FAILURE, 0, 610 gettext ("only one option of -G and -r is allowed")); 611 ld_state.file_type = relocatable_file_type; 612 break; 613 614 case 'S': 615 ld_state.strip = strip_debug; 616 break; 617 618 case 't': 619 ld_state.trace_files = true; 620 break; 621 622 case 'v': 623 verbose = 1; 624 break; 625 626 case 'z': 627 /* The SysV linker used 'z' to pass various flags to the linker. 628 We follow this. See 'parse_z_option' for the options we 629 recognize. */ 630 parse_z_option (arg); 631 break; 632 633 case ARGP_pagesize: 634 { 635 char *endp; 636 ld_state.pagesize = strtoul (arg, &endp, 0); 637 if (*endp != '\0') 638 { 639 if (endp[1] == '\0' && tolower (*endp) == 'k') 640 ld_state.pagesize *= 1024; 641 else if (endp[1] == '\0' && tolower (*endp) == 'm') 642 ld_state.pagesize *= 1024 * 1024; 643 else 644 { 645 error (0, 0, 646 gettext ("invalid page size value '%s': ignored"), 647 arg); 648 ld_state.pagesize = 0; 649 } 650 } 651 } 652 break; 653 654 case 'R': 655 add_rxxpath (&ld_state.rpath, arg); 656 break; 657 658 case ARGP_rpath_link: 659 add_rxxpath (&ld_state.rpath_link, arg); 660 break; 661 662 case ARGP_runpath: 663 add_rxxpath (&ld_state.runpath, arg); 664 break; 665 666 case ARGP_runpath_link: 667 add_rxxpath (&ld_state.runpath_link, arg); 668 break; 669 670 case ARGP_gc_sections: 671 case ARGP_no_gc_sections: 672 ld_state.gc_sections = key == ARGP_gc_sections; 673 break; 674 675 case ARGP_eh_frame_hdr: 676 ld_state.eh_frame_hdr = true; 677 break; 678 679 case ARGP_hash_style: 680 if (strcmp (arg, "gnu") == 0) 681 ld_state.hash_style = hash_style_gnu; 682 else if (strcmp (arg, "both") == 0) 683 ld_state.hash_style = hash_style_gnu | hash_style_sysv; 684 else if (strcmp (arg, "sysv") == 0) 685 ld_state.hash_style = hash_style_sysv; 686 else 687 error (EXIT_FAILURE, 0, gettext ("invalid hash style '%s'"), arg); 688 break; 689 690 case ARGP_build_id: 691 if (arg == NULL) 692 ld_state.build_id = "sha1"; 693 else if (strcmp (arg, "uuid") != 0 694 && strcmp (arg, "md5") != 0 695 && strcmp (arg, "sha1") != 0 696 && !valid_hexarg (arg)) 697 error (EXIT_FAILURE, 0, gettext ("invalid build-ID style '%s'"), arg); 698 else 699 ld_state.build_id = arg; 700 break; 701 702 case 's': 703 if (arg == NULL) 704 { 705 if (ld_state.strip == strip_all) 706 ld_state.strip = strip_everything; 707 else 708 ld_state.strip = strip_all; 709 break; 710 } 711 /* FALLTHROUGH */ 712 713 case 'e': 714 case 'o': 715 case 'O': 716 case ARGP_whole_archive: 717 case ARGP_no_whole_archive: 718 case ARGP_as_needed: 719 case ARGP_no_as_needed: 720 case 'L': 721 case '(': 722 case ')': 723 case 'l': 724 case ARGP_static: 725 case ARGP_dynamic: 726 case ARGP_version_script: 727 /* We'll handle these in the second pass. */ 728 break; 729 730 case ARGP_KEY_ARG: 731 { 732 struct file_list *newp; 733 734 newp = (struct file_list *) xmalloc (sizeof (struct file_list)); 735 newp->name = arg; 736#ifndef NDEBUG 737 newp->next = NULL; 738#endif 739 CSNGL_LIST_ADD_REAR (input_file_list, newp); 740 } 741 break; 742 743#if YYDEBUG 744 case ARGP_yydebug: 745 lddebug = 1; 746 break; 747#endif 748 749 case ARGP_no_undefined: 750 ld_state.nodefs = false; 751 break; 752 753 case ARGP_conserve: 754 conserve_memory = 1; 755 break; 756 757 default: 758 return ARGP_ERR_UNKNOWN; 759 } 760 return 0; 761} 762 763 764/* Handle program arguments for real. */ 765static error_t 766parse_opt_2nd (int key, char *arg, 767 struct argp_state *state __attribute__ ((unused))) 768{ 769 static bool group_start_requested; 770 static bool group_end_requested; 771 772 switch (key) 773 { 774 case 'B': 775 parse_B_option_2 (arg); 776 break; 777 778 case 'e': 779 ld_state.entry = arg; 780 break; 781 782 case 'o': 783 if (ld_state.outfname != NULL) 784 { 785 error (0, 0, gettext ("More than one output file name given.")); 786 see_help: 787 argp_help (&argp_2nd, stderr, ARGP_HELP_SEE, "ld"); 788 exit (EXIT_FAILURE); 789 } 790 ld_state.outfname = arg; 791 break; 792 793 case 'O': 794 if (arg == NULL) 795 ld_state.optlevel = 1; 796 else 797 { 798 char *endp; 799 unsigned long int level = strtoul (arg, &endp, 10); 800 if (*endp != '\0') 801 { 802 error (0, 0, gettext ("Invalid optimization level `%s'"), arg); 803 goto see_help; 804 } 805 ld_state.optlevel = level; 806 } 807 break; 808 809 case ARGP_whole_archive: 810 ld_state.extract_rule = allextract; 811 break; 812 case ARGP_no_whole_archive: 813 ld_state.extract_rule = defaultextract; 814 break; 815 816 case ARGP_as_needed: 817 ld_state.as_needed = true; 818 break; 819 case ARGP_no_as_needed: 820 ld_state.as_needed = false; 821 break; 822 823 case ARGP_static: 824 case ARGP_dynamic: 825 /* Enable/disable use for DSOs. */ 826 ld_state.statically = key == ARGP_static; 827 break; 828 829 case 'z': 830 /* The SysV linker used 'z' to pass various flags to the linker. 831 We follow this. See 'parse_z_option' for the options we 832 recognize. */ 833 parse_z_option_2 (arg); 834 break; 835 836 case ARGP_version_script: 837 read_version_script (arg); 838 break; 839 840 case 'L': 841 /* Add a new search directory. */ 842 ld_new_searchdir (arg); 843 break; 844 845 case '(': 846 /* Start a link group. We have to be able to determine the object 847 file which is named next. Do this by remembering a pointer to 848 the pointer which will point to the next object. */ 849 if (verbose && (group_start_requested || !group_end_requested)) 850 error (0, 0, gettext ("nested -( -) groups are not allowed")); 851 852 /* Increment the nesting level. */ 853 ++group_level; 854 855 /* Record group start. */ 856 group_start_requested = true; 857 group_end_requested = false; 858 break; 859 860 case ')': 861 /* End a link group. If there is no group open this is clearly 862 a bug. If there is a group open insert a back reference 863 pointer in the record for the last object of the group. If 864 there is no new object or just one don't do anything. */ 865 if (!group_end_requested) 866 { 867 if (group_level == 0) 868 { 869 error (0, 0, gettext ("-) without matching -(")); 870 goto see_help; 871 } 872 } 873 else 874 last_file->group_end = true; 875 876 if (group_level > 0) 877 --group_level; 878 break; 879 880 case 'l': 881 case ARGP_KEY_ARG: 882 { 883 while (last_file != NULL) 884 /* Try to open the file. */ 885 error_loading |= FILE_PROCESS (-1, last_file, &ld_state, &last_file); 886 887 last_file = ld_new_inputfile (arg, 888 key == 'l' 889 ? archive_file_type 890 : relocatable_file_type); 891 if (group_start_requested) 892 { 893 last_file->group_start = true; 894 895 group_start_requested = false; 896 group_end_requested = true; 897 } 898 } 899 break; 900 901 default: 902 /* We can catch all other options here. They either have 903 already been handled or, if the parameter was not correct, 904 the error has been reported. */ 905 break; 906 } 907 return 0; 908} 909 910 911/* Load all the DSOs named as dependencies in other DSOs we already 912 loaded. */ 913static void 914load_needed (void) 915{ 916 struct usedfiles *first; 917 struct usedfiles *runp; 918 919 /* XXX There is one problem here: do we allow references from 920 regular object files to be satisfied by these implicit 921 dependencies? The old linker allows this and several libraries 922 depend on this. Solaris' linker does not allow this; it provides 923 the user with a comprehensive error message explaining the 924 situation. 925 926 XXX IMO the old ld behavior is correct since this is also how the 927 dynamic linker will work. It will look for unresolved references 928 in all loaded DSOs. 929 930 XXX Should we add an option to get Solaris compatibility? */ 931 if (ld_state.needed == NULL) 932 return; 933 934 runp = first = ld_state.needed->next; 935 do 936 { 937 struct usedfiles *ignore; 938 struct usedfiles *next = runp->next; 939 int err; 940 941 err = FILE_PROCESS (-1, runp, &ld_state, &ignore); 942 if (err != 0) 943 /* Something went wrong. */ 944 exit (err); 945 946 runp = next; 947 } 948 while (runp != first); 949} 950 951 952/* Print the version information. */ 953static void 954print_version (FILE *stream, struct argp_state *state __attribute__ ((unused))) 955{ 956 fprintf (stream, "ld (%s) %s\n", PACKAGE_NAME, PACKAGE_VERSION); 957 fprintf (stream, gettext ("\ 958Copyright (C) %s Red Hat, Inc.\n\ 959This is free software; see the source for copying conditions. There is NO\n\ 960warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\ 961"), "2008"); 962 fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper"); 963} 964 965 966/* There are a lot of -z options, parse them here. Some of them have 967 to be parsed in the first pass, others must be handled in the 968 second pass. */ 969static void 970parse_z_option (const char *arg) 971{ 972 if (strcmp (arg, "nodefaultlib") == 0 973 /* This is only meaningful if we create a DSO. */ 974 && ld_state.file_type == dso_file_type) 975 ld_state.dt_flags_1 |= DF_1_NODEFLIB; 976 else if (strcmp (arg, "muldefs") == 0) 977 ld_state.muldefs = true; 978 else if (strcmp (arg, "nodefs") == 0) 979 ld_state.nodefs = true; 980 else if (strcmp (arg, "defs") == 0) 981 ld_state.nodefs = false; 982 else if (strcmp (arg, "now") == 0) 983 /* We could also set the DF_1_NOW flag in DT_FLAGS_1 but this isn't 984 necessary. */ 985 ld_state.dt_flags |= DF_BIND_NOW; 986 else if (strcmp (arg, "origin") == 0) 987 /* We could also set the DF_1_ORIGIN flag in DT_FLAGS_1 but this isn't 988 necessary. */ 989 ld_state.dt_flags |= DF_ORIGIN; 990 else if (strcmp (arg, "nodelete") == 0 991 /* This is only meaningful if we create a DSO. */ 992 && ld_state.file_type == dso_file_type) 993 ld_state.dt_flags_1 |= DF_1_NODELETE; 994 else if (strcmp (arg, "initfirst") == 0) 995 ld_state.dt_flags_1 |= DF_1_INITFIRST; 996 else if (strcmp (arg, "nodlopen") == 0 997 /* This is only meaningful if we create a DSO. */ 998 && ld_state.file_type == dso_file_type) 999 ld_state.dt_flags_1 |= DF_1_NOOPEN; 1000 else if (strcmp (arg, "systemlibrary") == 0) 1001 ld_state.is_system_library = true; 1002 else if (strcmp (arg, "execstack") == 0) 1003 ld_state.execstack = execstack_true; 1004 else if (strcmp (arg, "noexecstack") == 0) 1005 ld_state.execstack = execstack_false_force; 1006 else if (strcmp (arg, "allextract") != 0 1007 && strcmp (arg, "defaultextract") != 0 1008 && strcmp (arg, "weakextract") != 0 1009 && strcmp (arg, "lazyload") != 0 1010 && strcmp (arg, "nolazyload") != 0 1011 && strcmp (arg, "ignore") != 0 1012 && strcmp (arg, "record") != 0) 1013 error (0, 0, gettext ("unknown option `-%c %s'"), 'z', arg); 1014} 1015 1016 1017static void 1018parse_z_option_2 (const char *arg) 1019{ 1020 if (strcmp (arg, "allextract") == 0) 1021 ld_state.extract_rule = allextract; 1022 else if (strcmp (arg, "defaultextract") == 0) 1023 ld_state.extract_rule = defaultextract; 1024 else if (strcmp (arg, "weakextract") == 0) 1025 ld_state.extract_rule = weakextract; 1026 else if (strcmp (arg, "lazyload") == 0) 1027 ld_state.lazyload = true; 1028 else if (strcmp (arg, "nolazyload") == 0) 1029 ld_state.lazyload = false; 1030 else if (strcmp (arg, "ignore") == 0) 1031 ld_state.as_needed = true; 1032 else if (strcmp (arg, "record") == 0) 1033 ld_state.as_needed = false; 1034} 1035 1036 1037/* There are a lot of -B options, parse them here. */ 1038static void 1039parse_B_option (const char *arg) 1040{ 1041 if (strcmp (arg, "local") == 0) 1042 ld_state.default_bind_local = true; 1043 else if (strcmp (arg, "symbolic") != 0 1044 && strcmp (arg, "static") != 0 1045 && strcmp (arg, "dynamic") != 0) 1046 error (0, 0, gettext ("unknown option '-%c %s'"), 'B', arg); 1047} 1048 1049 1050/* The same functionality, but called in the second pass over the 1051 parameters. */ 1052static void 1053parse_B_option_2 (const char *arg) 1054{ 1055 if (strcmp (arg, "static") == 0) 1056 ld_state.statically = true; 1057 else if (strcmp (arg, "dynamic") == 0) 1058 ld_state.statically = false; 1059 else if (strcmp (arg, "symbolic") == 0 1060 /* This is only meaningful if we create a DSO. */ 1061 && ld_state.file_type == dso_file_type) 1062 ld_state.dt_flags |= DF_SYMBOLIC; 1063} 1064 1065 1066static void 1067determine_output_format (void) 1068{ 1069 /* First change the 'input_file_list' variable in a simple 1070 single-linked list. */ 1071 struct file_list *last = input_file_list; 1072 input_file_list = input_file_list->next; 1073 last->next = NULL; 1074 1075 /* Determine the target configuration which we are supposed to use. 1076 The user can use the '-m' option to select one. If this is 1077 missing we are trying to load one file and determine the 1078 architecture from that. */ 1079 if (emulation != NULL) 1080 { 1081 ld_state.ebl = ebl_openbackend_emulation (emulation); 1082 1083 assert (ld_state.ebl != NULL); 1084 } 1085 else 1086 { 1087 /* Find an ELF input file and let it determine the ELf backend. */ 1088 struct file_list *runp = input_file_list; 1089 1090 while (runp != NULL) 1091 { 1092 int fd = open (runp->name, O_RDONLY); 1093 if (fd != -1) 1094 { 1095 int try (Elf *elf) 1096 { 1097 int result = 0; 1098 1099 if (elf == NULL) 1100 return 0; 1101 1102 if (elf_kind (elf) == ELF_K_ELF) 1103 { 1104 /* We have an ELF file. We now can find out 1105 what the output format should be. */ 1106 XElf_Ehdr_vardef(ehdr); 1107 1108 /* Get the ELF header of the object. */ 1109 xelf_getehdr (elf, ehdr); 1110 if (ehdr != NULL) 1111 ld_state.ebl = 1112 ebl_openbackend_machine (ehdr->e_machine); 1113 1114 result = 1; 1115 } 1116 else if (elf_kind (elf) == ELF_K_AR) 1117 { 1118 /* Try the archive members. This could 1119 potentially lead to wrong results if the 1120 archive contains files for more than one 1121 architecture. But this is the user's 1122 problem. */ 1123 Elf *subelf; 1124 Elf_Cmd cmd = ELF_C_READ_MMAP; 1125 1126 while ((subelf = elf_begin (fd, cmd, elf)) != NULL) 1127 { 1128 cmd = elf_next (subelf); 1129 1130 if (try (subelf) != 0) 1131 break; 1132 } 1133 } 1134 1135 elf_end (elf); 1136 1137 return result; 1138 } 1139 1140 if (try (elf_begin (fd, ELF_C_READ_MMAP, NULL)) != 0) 1141 /* Found a file. */ 1142 break; 1143 } 1144 1145 runp = runp->next; 1146 } 1147 1148 if (ld_state.ebl == NULL) 1149 { 1150 error (0, 0, gettext ("\ 1151could not find input file to determine output file format")); 1152 error (EXIT_FAILURE, 0, gettext ("\ 1153try again with an appropriate '-m' parameter")); 1154 } 1155 } 1156 1157 /* We don't need the list of input files anymore. The second run over 1158 the parameters will handle them. */ 1159 while (input_file_list != NULL) 1160 { 1161 struct file_list *oldp = input_file_list; 1162 input_file_list = input_file_list->next; 1163 free (oldp); 1164 } 1165 1166 /* We also know now what kind of file we are supposed to create. If 1167 the user hasn't selected anythign we create and executable. */ 1168 if (ld_state.file_type == no_file_type) 1169 ld_state.file_type = executable_file_type; 1170} 1171 1172/* Add DIR to the list of directories searched for object files and 1173 libraries. */ 1174void 1175ld_new_searchdir (const char *dir) 1176{ 1177 struct pathelement *newpath; 1178 1179 newpath = (struct pathelement *) 1180 obstack_calloc (&ld_state.smem, sizeof (struct pathelement)); 1181 1182 newpath->pname = dir; 1183 1184 /* Enqueue the file. */ 1185 if (ld_state.tailpaths == NULL) 1186 ld_state.paths = ld_state.tailpaths = newpath; 1187 else 1188 { 1189 ld_state.tailpaths->next = newpath; 1190 ld_state.tailpaths = newpath; 1191 } 1192} 1193 1194 1195struct usedfiles * 1196ld_new_inputfile (const char *fname, enum file_type type) 1197{ 1198 struct usedfiles *newfile = (struct usedfiles *) 1199 obstack_calloc (&ld_state.smem, sizeof (struct usedfiles)); 1200 1201 newfile->soname = newfile->fname = newfile->rfname = fname; 1202 newfile->file_type = type; 1203 newfile->extract_rule = ld_state.extract_rule; 1204 newfile->as_needed = ld_state.as_needed; 1205 newfile->lazyload = ld_state.lazyload; 1206 newfile->status = not_opened; 1207 1208 return newfile; 1209} 1210 1211 1212/* Create an array listing all the sections. We will than pass this 1213 array to a system specific function which can reorder it at will. 1214 The functions can also merge sections if this is what is 1215 wanted. */ 1216static void 1217collect_sections (void) 1218{ 1219 void *p ; 1220 struct scnhead *h; 1221 size_t cnt; 1222 1223 /* We have that many sections. At least for now. */ 1224 ld_state.nallsections = ld_state.section_tab.filled; 1225 1226 /* Allocate the array. We allocate one more entry than computed so 1227 far since we might need a new section for the copy relocations. */ 1228 ld_state.allsections = 1229 (struct scnhead **) obstack_alloc (&ld_state.smem, 1230 (ld_state.nallsections + 1) 1231 * sizeof (struct scnhead *)); 1232 1233 /* Fill the array. We rely here on the hash table iterator to 1234 return the entries in the order they were added. */ 1235 cnt = 0; 1236 p = NULL; 1237 while ((h = ld_section_tab_iterate (&ld_state.section_tab, &p)) != NULL) 1238 { 1239 struct scninfo *runp; 1240 bool used = false; 1241 1242 if (h->kind == scn_normal) 1243 { 1244 runp = h->last; 1245 do 1246 { 1247 if (h->type == SHT_REL || h->type == SHT_RELA) 1248 { 1249 if (runp->used) 1250 /* This is a relocation section. If the section 1251 it is relocating is used in the result so must 1252 the relocation section. */ 1253 runp->used 1254 = runp->fileinfo->scninfo[SCNINFO_SHDR (runp->shdr).sh_info].used; 1255 } 1256 1257 /* Accumulate the result. */ 1258 used |= runp->used; 1259 1260 /* Next input section. */ 1261 runp = runp->next; 1262 } 1263 while (runp != h->last); 1264 1265 h->used = used; 1266 } 1267 1268 ld_state.allsections[cnt++] = h; 1269 } 1270 ld_state.nusedsections = cnt; 1271 1272 assert (cnt == ld_state.nallsections); 1273} 1274 1275 1276/* Add given path to the end of list. */ 1277static void 1278add_rxxpath (struct pathelement **pathp, const char *str) 1279{ 1280 struct pathelement *newp; 1281 1282 /* The path elements can in theory be freed after we read all the 1283 files. But the amount of memory we are talking about is small 1284 and the cost of free() calls is not neglectable. */ 1285 newp = (struct pathelement *) obstack_alloc (&ld_state.smem, sizeof (*newp)); 1286 newp->pname = str; 1287 newp->exist = 0; 1288#ifndef NDEBUG 1289 newp->next = NULL; 1290#endif 1291 1292 CSNGL_LIST_ADD_REAR (*pathp, newp); 1293} 1294 1295 1296/* Convert lists of possibly colon-separated directory lists into lists 1297 where each entry is for a single directory. */ 1298static void 1299normalize_dirlist (struct pathelement **pathp) 1300{ 1301 struct pathelement *firstp = *pathp; 1302 1303 do 1304 { 1305 const char *pname = (*pathp)->pname; 1306 const char *colonp = strchrnul (pname, ':'); 1307 1308 if (colonp != NULL) 1309 { 1310 struct pathelement *lastp = *pathp; 1311 struct pathelement *newp; 1312 1313 while (1) 1314 { 1315 if (colonp == pname) 1316 lastp->pname = "."; 1317 else 1318 lastp->pname = obstack_strndup (&ld_state.smem, pname, 1319 colonp - pname); 1320 1321 if (*colonp == '\0') 1322 break; 1323 pname = colonp + 1; 1324 1325 newp = (struct pathelement *) obstack_alloc (&ld_state.smem, 1326 sizeof (*newp)); 1327 newp->next = lastp->next; 1328 newp->exist = 0; 1329 lastp = lastp->next = newp; 1330 1331 colonp = strchrnul (pname, ':'); 1332 } 1333 1334 pathp = &lastp->next; 1335 } 1336 else 1337 pathp = &(*pathp)->next; 1338 } 1339 while (*pathp != firstp); 1340} 1341 1342 1343/* Called after all parameters are parsed to bring the runpath/rpath 1344 information into a usable form. */ 1345static void 1346gen_rxxpath_data (void) 1347{ 1348 char *ld_library_path2; 1349 1350 /* Convert the information in true single-linked lists for easy use. 1351 At this point we also discard the rpath information if runpath 1352 information is provided. rpath is deprecated and should not be 1353 used (or ever be invented for that matter). */ 1354 if (ld_state.rpath != NULL) 1355 { 1356 struct pathelement *endp = ld_state.rpath; 1357 ld_state.rpath = ld_state.rpath->next; 1358 endp->next = NULL; 1359 } 1360 if (ld_state.rpath_link != NULL) 1361 { 1362 struct pathelement *endp = ld_state.rpath_link; 1363 ld_state.rpath_link = ld_state.rpath_link->next; 1364 endp->next = NULL; 1365 } 1366 1367 if (ld_state.runpath != NULL) 1368 { 1369 struct pathelement *endp = ld_state.runpath; 1370 ld_state.runpath = ld_state.runpath->next; 1371 endp->next = NULL; 1372 1373 /* If rpath information is also available discard it. 1374 XXX Should there be a possibility to avoid this? */ 1375 while (ld_state.rpath != NULL) 1376 { 1377 struct pathelement *old = ld_state.rpath; 1378 ld_state.rpath = ld_state.rpath->next; 1379 free (old); 1380 } 1381 } 1382 if (ld_state.runpath_link != NULL) 1383 { 1384 struct pathelement *endp = ld_state.runpath_link; 1385 ld_state.runpath_link = ld_state.runpath_link->next; 1386 endp->next = NULL; 1387 1388 /* If rpath information is also available discard it. 1389 XXX Should there be a possibility to avoid this? */ 1390 while (ld_state.rpath_link != NULL) 1391 { 1392 struct pathelement *old = ld_state.rpath_link; 1393 ld_state.rpath_link = ld_state.rpath_link->next; 1394 free (old); 1395 } 1396 1397 /* The information in the strings in the list can actually be 1398 directory lists themselves, with entries separated by colons. 1399 Convert the list now to a list with one list entry for each 1400 directory. */ 1401 normalize_dirlist (&ld_state.runpath_link); 1402 } 1403 else if (ld_state.rpath_link != NULL) 1404 /* Same as for the runpath_link above. */ 1405 normalize_dirlist (&ld_state.rpath_link); 1406 1407 1408 /* As a related task, handle the LD_LIBRARY_PATH value here. First 1409 we have to possibly split the value found (if it contains a 1410 semicolon). Then we have to split the value in list of 1411 directories, i.e., split at the colons. */ 1412 if (ld_library_path1 != NULL) 1413 { 1414 ld_library_path2 = strchr (ld_library_path1, ';'); 1415 if (ld_library_path2 == NULL) 1416 { 1417 /* If no semicolon is present the directories are looked at 1418 after the -L parameters (-> ld_library_path2). */ 1419 ld_library_path2 = ld_library_path1; 1420 ld_library_path1 = NULL; 1421 } 1422 else 1423 { 1424 /* NUL terminate the first part. */ 1425 *ld_library_path2++ = '\0'; 1426 1427 /* Convert the string value in a list. */ 1428 add_rxxpath (&ld_state.ld_library_path1, ld_library_path1); 1429 normalize_dirlist (&ld_state.ld_library_path1); 1430 } 1431 1432 add_rxxpath (&ld_state.ld_library_path2, ld_library_path2); 1433 normalize_dirlist (&ld_state.ld_library_path2); 1434 } 1435} 1436 1437 1438static void 1439read_version_script (const char *fname) 1440{ 1441 /* Open the file. The name is supposed to be the complete (relative 1442 or absolute) path. No search along a path will be performed. */ 1443 ldin = fopen (fname, "r"); 1444 if (ldin == NULL) 1445 error (EXIT_FAILURE, errno, gettext ("cannot read version script '%s'"), 1446 fname); 1447 /* No need for locking. */ 1448 __fsetlocking (ldin, FSETLOCKING_BYCALLER); 1449 1450 /* Tell the parser that this is a version script. */ 1451 ld_scan_version_script = 1; 1452 1453 ldlineno = 1; 1454 ldin_fname = fname; 1455 if (ldparse () != 0) 1456 /* Something went wrong during parsing. */ 1457 exit (EXIT_FAILURE); 1458 1459 fclose (ldin); 1460} 1461 1462 1463static void 1464create_lscript_symbols (void) 1465{ 1466 /* Walk through the data from the linker script and generate all the 1467 symbols which are required to be present and and those marked 1468 with PROVIDE if there is a undefined reference. */ 1469 if (ld_state.output_segments == NULL) 1470 return; 1471 1472 struct output_segment *segment = ld_state.output_segments->next; 1473 do 1474 { 1475 struct output_rule *orule; 1476 1477 for (orule = segment->output_rules; orule != NULL; orule = orule->next) 1478 if (orule->tag == output_assignment 1479 /* The assignments to "." (i.e., the PC) have to be 1480 ignored here. */ 1481 && strcmp (orule->val.assignment->variable, ".") != 0) 1482 { 1483 struct symbol *s = ld_state.unresolved; 1484 1485 /* Check whether the symbol is needed. */ 1486 if (likely (s != NULL)) 1487 { 1488 struct symbol *first = s; 1489 const char *providename = orule->val.assignment->variable; 1490 1491 /* Determine whether the provided symbol is still 1492 undefined. */ 1493 // XXX TODO Loop inside a loop. Gag! Must rewrite. */ 1494 do 1495 if (strcmp (s->name, providename) == 0) 1496 { 1497 /* Not defined but referenced. */ 1498 if (unlikely (!s->defined)) 1499 { 1500 /* Put on the list of symbols. First remove it from 1501 whatever list it currently is on. */ 1502 CDBL_LIST_DEL (ld_state.unresolved, s); 1503 --ld_state.nunresolved; 1504 goto use_it; 1505 } 1506 1507 if (unlikely (!orule->val.assignment->provide_flag)) 1508 { 1509 /* The symbol is already defined and now again 1510 in the linker script. This is an error. */ 1511 error (0, 0, gettext ("\ 1512duplicate definition of '%s' in linker script"), 1513 providename); 1514 goto next_rule; 1515 } 1516 } 1517 while ((s = s->next) != first); 1518 } 1519 1520 /* If the symbol only has to be provided if it is needed, 1521 ignore it here since it is not undefined. */ 1522 if (orule->val.assignment->provide_flag) 1523 continue; 1524 1525 /* Allocate memory for this new symbol. */ 1526 s = (struct symbol *) 1527 obstack_calloc (&ld_state.smem, sizeof (struct symbol)); 1528 1529 /* Initialize it. */ 1530 s->name = orule->val.assignment->variable; 1531 1532 /* Insert it into the symbol hash table. */ 1533 unsigned long int hval = elf_hash (s->name); 1534 if (unlikely (ld_symbol_tab_insert (&ld_state.symbol_tab, 1535 hval, s) != 0)) 1536 { 1537 /* This means the symbol is defined somewhere else. 1538 Maybe it comes from a DSO or so. Get the 1539 definition. */ 1540 free (s); 1541 struct symbol *old = ld_symbol_tab_find (&ld_state.symbol_tab, 1542 hval, s); 1543 assert (old != NULL); 1544 free (s); 1545 1546 /* If this is a definition from the application itself 1547 this means a duplicate definition. */ 1548 if (! old->in_dso) 1549 { 1550 error (0, 0, gettext ("\ 1551duplicate definition of '%s' in linker script"), 1552 s->name); 1553 goto next_rule; 1554 } 1555 1556 /* We use the definition from the linker script. */ 1557 s = old; 1558 } 1559 1560 use_it: 1561 /* The symbol is (now) defined. */ 1562 s->defined = 1; 1563 s->type = STT_NOTYPE; 1564 1565 /* Add a reference to the symbol record. We will come 1566 across it when creating the output file. */ 1567 orule->val.assignment->sym = s; 1568 1569 SNGL_LIST_PUSH (ld_state.lscript_syms, s); 1570 ++ld_state.nlscript_syms; 1571 1572 next_rule: 1573 ; 1574 } 1575 1576 segment = segment->next; 1577 } 1578 while (segment != ld_state.output_segments->next); 1579} 1580 1581 1582/* Create creation of spection section symbols representing sections in the 1583 output file. This is done for symbols like _GLOBAL_OFFSET_TABLE_ and 1584 _DYNAMIC. */ 1585static void 1586create_special_section_symbol (struct symbol **symp, const char *name) 1587{ 1588 if (*symp == NULL) 1589 { 1590 /* No symbol defined found yet. Create one. */ 1591 struct symbol *newsym = (struct symbol *) 1592 obstack_calloc (&ld_state.smem, sizeof (*newsym)); 1593 1594 newsym->name = name; 1595 // XXX Should we mark the symbol hidden? They are hardly useful 1596 // used outside the current object. 1597 1598 /* Add to the symbol table. */ 1599 if (unlikely (ld_symbol_tab_insert (&ld_state.symbol_tab, 1600 elf_hash (name), newsym) != 0)) 1601 abort (); 1602 1603 *symp = newsym; 1604 } 1605 else if ((*symp)->defined) 1606 /* Cannot happen. We do use this symbol from any input file. */ 1607 abort (); 1608 1609 (*symp)->defined = 1; 1610 (*symp)->local = 1; 1611 (*symp)->hidden = 1; 1612 (*symp)->type = STT_OBJECT; 1613 1614 ++ld_state.nsymtab; 1615} 1616 1617 1618#include "debugpred.h" 1619