binutils 2.22: Add READMEs and local modifications
[dragonfly.git] / contrib / binutils-2.22 / gold / options.cc
CommitLineData
dfe305e9
JM
1// options.c -- handle command line options for gold
2
3// Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
4// Written by Ian Lance Taylor <iant@google.com>.
5
6// This file is part of gold.
7
8// This program is free software; you can redistribute it and/or modify
9// it under the terms of the GNU General Public License as published by
10// the Free Software Foundation; either version 3 of the License, or
11// (at your option) any later version.
12
13// This program is distributed in the hope that it will be useful,
14// but WITHOUT ANY WARRANTY; without even the implied warranty of
15// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16// GNU General Public License for more details.
17
18// You should have received a copy of the GNU General Public License
19// along with this program; if not, write to the Free Software
20// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21// MA 02110-1301, USA.
22
23#include "gold.h"
24
25#include <cerrno>
26#include <cstdlib>
27#include <cstring>
28#include <fstream>
29#include <vector>
30#include <iostream>
31#include <sys/stat.h>
32#include "filenames.h"
33#include "libiberty.h"
34#include "demangle.h"
35#include "../bfd/bfdver.h"
36
37#include "debug.h"
38#include "script.h"
39#include "target-select.h"
40#include "options.h"
41#include "plugin.h"
42
43namespace gold
44{
45
46General_options
47Position_dependent_options::default_options_;
48
49namespace options
50{
51
52// This flag is TRUE if we should register the command-line options as they
53// are constructed. It is set after construction of the options within
54// class Position_dependent_options.
55static bool ready_to_register = false;
56
57// This global variable is set up as General_options is constructed.
58static std::vector<const One_option*> registered_options;
59
60// These are set up at the same time -- the variables that accept one
61// dash, two, or require -z. A single variable may be in more than
62// one of these data structures.
63typedef Unordered_map<std::string, One_option*> Option_map;
64static Option_map* long_options = NULL;
65static One_option* short_options[128];
66
67void
68One_option::register_option()
69{
70 if (!ready_to_register)
71 return;
72
73 registered_options.push_back(this);
74
75 // We can't make long_options a static Option_map because we can't
76 // guarantee that will be initialized before register_option() is
77 // first called.
78 if (long_options == NULL)
79 long_options = new Option_map;
80
81 // TWO_DASHES means that two dashes are preferred, but one is ok too.
82 if (!this->longname.empty())
83 (*long_options)[this->longname] = this;
84
85 const int shortname_as_int = static_cast<int>(this->shortname);
86 gold_assert(shortname_as_int >= 0 && shortname_as_int < 128);
87 if (this->shortname != '\0')
88 {
89 gold_assert(short_options[shortname_as_int] == NULL);
90 short_options[shortname_as_int] = this;
91 }
92}
93
94void
95One_option::print() const
96{
97 bool comma = false;
98 printf(" ");
99 int len = 2;
100 if (this->shortname != '\0')
101 {
102 len += printf("-%c", this->shortname);
103 if (this->helparg)
104 {
105 // -z takes long-names only.
106 gold_assert(this->dashes != DASH_Z);
107 len += printf(" %s", gettext(this->helparg));
108 }
109 comma = true;
110 }
111 if (!this->longname.empty()
112 && !(this->longname[0] == this->shortname
113 && this->longname[1] == '\0'))
114 {
115 if (comma)
116 len += printf(", ");
117 switch (this->dashes)
118 {
119 case options::ONE_DASH: case options::EXACTLY_ONE_DASH:
120 len += printf("-");
121 break;
122 case options::TWO_DASHES: case options::EXACTLY_TWO_DASHES:
123 len += printf("--");
124 break;
125 case options::DASH_Z:
126 len += printf("-z ");
127 break;
128 default:
129 gold_unreachable();
130 }
131 len += printf("%s", this->longname.c_str());
132 if (this->helparg)
133 {
134 // For most options, we print "--frob FOO". But for -z
135 // we print "-z frob=FOO".
136 len += printf("%c%s", this->dashes == options::DASH_Z ? '=' : ' ',
137 gettext(this->helparg));
138 }
139 }
140
141 if (len >= 30)
142 {
143 printf("\n");
144 len = 0;
145 }
146 for (; len < 30; ++len)
147 std::putchar(' ');
148
149 // TODO: if we're boolean, add " (default)" when appropriate.
150 printf("%s\n", gettext(this->helpstring));
151}
152
153void
154help()
155{
156 printf(_("Usage: %s [options] file...\nOptions:\n"), gold::program_name);
157
158 std::vector<const One_option*>::const_iterator it;
159 for (it = registered_options.begin(); it != registered_options.end(); ++it)
160 (*it)->print();
161
162 // config.guess and libtool.m4 look in ld --help output for the
163 // string "supported targets".
164 printf(_("%s: supported targets:"), gold::program_name);
165 std::vector<const char*> supported_names;
166 gold::supported_target_names(&supported_names);
167 for (std::vector<const char*>::const_iterator p = supported_names.begin();
168 p != supported_names.end();
169 ++p)
170 printf(" %s", *p);
171 printf("\n");
172
173 printf(_("%s: supported emulations:"), gold::program_name);
174 supported_names.clear();
175 gold::supported_emulation_names(&supported_names);
176 for (std::vector<const char*>::const_iterator p = supported_names.begin();
177 p != supported_names.end();
178 ++p)
179 printf(" %s", *p);
180 printf("\n");
181
182 // REPORT_BUGS_TO is defined in bfd/bfdver.h.
183 const char* report = REPORT_BUGS_TO;
184 if (*report != '\0')
185 printf(_("Report bugs to %s\n"), report);
186}
187
188// For bool, arg will be NULL (boolean options take no argument);
189// we always just set to true.
190void
191parse_bool(const char*, const char*, bool* retval)
192{
193 *retval = true;
194}
195
196void
197parse_uint(const char* option_name, const char* arg, int* retval)
198{
199 char* endptr;
200 *retval = strtol(arg, &endptr, 0);
201 if (*endptr != '\0' || retval < 0)
202 gold_fatal(_("%s: invalid option value (expected an integer): %s"),
203 option_name, arg);
204}
205
206void
207parse_int(const char* option_name, const char* arg, int* retval)
208{
209 char* endptr;
210 *retval = strtol(arg, &endptr, 0);
211 if (*endptr != '\0')
212 gold_fatal(_("%s: invalid option value (expected an integer): %s"),
213 option_name, arg);
214}
215
216void
217parse_uint64(const char* option_name, const char* arg, uint64_t* retval)
218{
219 char* endptr;
220 *retval = strtoull(arg, &endptr, 0);
221 if (*endptr != '\0')
222 gold_fatal(_("%s: invalid option value (expected an integer): %s"),
223 option_name, arg);
224}
225
226void
227parse_double(const char* option_name, const char* arg, double* retval)
228{
229 char* endptr;
230 *retval = strtod(arg, &endptr);
231 if (*endptr != '\0')
232 gold_fatal(_("%s: invalid option value "
233 "(expected a floating point number): %s"),
234 option_name, arg);
235}
236
237void
238parse_percent(const char* option_name, const char* arg, double* retval)
239{
240 char* endptr;
241 *retval = strtod(arg, &endptr) / 100.0;
242 if (*endptr != '\0')
243 gold_fatal(_("%s: invalid option value "
244 "(expected a floating point number): %s"),
245 option_name, arg);
246}
247
248void
249parse_string(const char* option_name, const char* arg, const char** retval)
250{
251 if (*arg == '\0')
252 gold_fatal(_("%s: must take a non-empty argument"), option_name);
253 *retval = arg;
254}
255
256void
257parse_optional_string(const char*, const char* arg, const char** retval)
258{
259 *retval = arg;
260}
261
262void
263parse_dirlist(const char*, const char* arg, Dir_list* retval)
264{
265 retval->push_back(Search_directory(arg, false));
266}
267
268void
269parse_set(const char*, const char* arg, String_set* retval)
270{
271 retval->insert(std::string(arg));
272}
273
274void
275parse_choices(const char* option_name, const char* arg, const char** retval,
276 const char* choices[], int num_choices)
277{
278 for (int i = 0; i < num_choices; i++)
279 if (strcmp(choices[i], arg) == 0)
280 {
281 *retval = arg;
282 return;
283 }
284
285 // If we get here, the user did not enter a valid choice, so we die.
286 std::string choices_list;
287 for (int i = 0; i < num_choices; i++)
288 {
289 choices_list += choices[i];
290 if (i != num_choices - 1)
291 choices_list += ", ";
292 }
293 gold_fatal(_("%s: must take one of the following arguments: %s"),
294 option_name, choices_list.c_str());
295}
296
297} // End namespace options.
298
299// Define the handler for "special" options (set via DEFINE_special).
300
301void
302General_options::parse_help(const char*, const char*, Command_line*)
303{
304 options::help();
305 ::exit(EXIT_SUCCESS);
306}
307
308void
309General_options::parse_version(const char* opt, const char*, Command_line*)
310{
311 bool print_short = (opt[0] == '-' && opt[1] == 'v');
312 gold::print_version(print_short);
313 this->printed_version_ = true;
314 if (!print_short)
315 ::exit(EXIT_SUCCESS);
316}
317
318void
319General_options::parse_V(const char*, const char*, Command_line*)
320{
321 gold::print_version(true);
322 this->printed_version_ = true;
323
324 printf(_(" Supported targets:\n"));
325 std::vector<const char*> supported_names;
326 gold::supported_target_names(&supported_names);
327 for (std::vector<const char*>::const_iterator p = supported_names.begin();
328 p != supported_names.end();
329 ++p)
330 printf(" %s\n", *p);
331
332 printf(_(" Supported emulations:\n"));
333 supported_names.clear();
334 gold::supported_emulation_names(&supported_names);
335 for (std::vector<const char*>::const_iterator p = supported_names.begin();
336 p != supported_names.end();
337 ++p)
338 printf(" %s\n", *p);
339}
340
341void
342General_options::parse_defsym(const char*, const char* arg,
343 Command_line* cmdline)
344{
345 cmdline->script_options().define_symbol(arg);
346}
347
348void
349General_options::parse_incremental(const char*, const char*,
350 Command_line*)
351{
352 this->incremental_mode_ = INCREMENTAL_AUTO;
353}
354
355void
356General_options::parse_no_incremental(const char*, const char*,
357 Command_line*)
358{
359 this->incremental_mode_ = INCREMENTAL_OFF;
360}
361
362void
363General_options::parse_incremental_full(const char*, const char*,
364 Command_line*)
365{
366 this->incremental_mode_ = INCREMENTAL_FULL;
367}
368
369void
370General_options::parse_incremental_update(const char*, const char*,
371 Command_line*)
372{
373 this->incremental_mode_ = INCREMENTAL_UPDATE;
374}
375
376void
377General_options::parse_incremental_changed(const char*, const char*,
378 Command_line*)
379{
380 this->implicit_incremental_ = true;
381 this->incremental_disposition_ = INCREMENTAL_CHANGED;
382}
383
384void
385General_options::parse_incremental_unchanged(const char*, const char*,
386 Command_line*)
387{
388 this->implicit_incremental_ = true;
389 this->incremental_disposition_ = INCREMENTAL_UNCHANGED;
390}
391
392void
393General_options::parse_incremental_unknown(const char*, const char*,
394 Command_line*)
395{
396 this->implicit_incremental_ = true;
397 this->incremental_disposition_ = INCREMENTAL_CHECK;
398}
399
400void
401General_options::parse_incremental_startup_unchanged(const char*, const char*,
402 Command_line*)
403{
404 this->implicit_incremental_ = true;
405 this->incremental_startup_disposition_ = INCREMENTAL_UNCHANGED;
406}
407
408void
409General_options::parse_library(const char*, const char* arg,
410 Command_line* cmdline)
411{
412 Input_file_argument::Input_file_type type;
413 const char* name;
414 if (arg[0] == ':')
415 {
416 type = Input_file_argument::INPUT_FILE_TYPE_SEARCHED_FILE;
417 name = arg + 1;
418 }
419 else
420 {
421 type = Input_file_argument::INPUT_FILE_TYPE_LIBRARY;
422 name = arg;
423 }
424 Input_file_argument file(name, type, "", false, *this);
425 cmdline->inputs().add_file(file);
426}
427
428#ifdef ENABLE_PLUGINS
429void
430General_options::parse_plugin(const char*, const char* arg,
431 Command_line*)
432{
433 this->add_plugin(arg);
434}
435
436// Parse --plugin-opt.
437
438void
439General_options::parse_plugin_opt(const char*, const char* arg,
440 Command_line*)
441{
442 this->add_plugin_option(arg);
443}
444#endif // ENABLE_PLUGINS
445
446void
447General_options::parse_R(const char* option, const char* arg,
448 Command_line* cmdline)
449{
450 struct stat s;
451 if (::stat(arg, &s) != 0 || S_ISDIR(s.st_mode))
452 this->add_to_rpath(arg);
453 else
454 this->parse_just_symbols(option, arg, cmdline);
455}
456
457void
458General_options::parse_just_symbols(const char*, const char* arg,
459 Command_line* cmdline)
460{
461 Input_file_argument file(arg, Input_file_argument::INPUT_FILE_TYPE_FILE,
462 "", true, *this);
463 cmdline->inputs().add_file(file);
464}
465
466// Handle --section-start.
467
468void
469General_options::parse_section_start(const char*, const char* arg,
470 Command_line*)
471{
472 const char* eq = strchr(arg, '=');
473 if (eq == NULL)
474 {
475 gold_error(_("invalid argument to --section-start; "
476 "must be SECTION=ADDRESS"));
477 return;
478 }
479
480 std::string section_name(arg, eq - arg);
481
482 ++eq;
483 const char* val_start = eq;
484 if (eq[0] == '0' && (eq[1] == 'x' || eq[1] == 'X'))
485 eq += 2;
486 if (*eq == '\0')
487 {
488 gold_error(_("--section-start address missing"));
489 return;
490 }
491 uint64_t addr = 0;
492 hex_init();
493 for (; *eq != '\0'; ++eq)
494 {
495 if (!hex_p(*eq))
496 {
497 gold_error(_("--section-start argument %s is not a valid hex number"),
498 val_start);
499 return;
500 }
501 addr <<= 4;
502 addr += hex_value(*eq);
503 }
504
505 this->section_starts_[section_name] = addr;
506}
507
508// Look up a --section-start value.
509
510bool
511General_options::section_start(const char* secname, uint64_t* paddr) const
512{
513 if (this->section_starts_.empty())
514 return false;
515 std::map<std::string, uint64_t>::const_iterator p =
516 this->section_starts_.find(secname);
517 if (p == this->section_starts_.end())
518 return false;
519 *paddr = p->second;
520 return true;
521}
522
523void
524General_options::parse_static(const char*, const char*, Command_line*)
525{
526 this->set_static(true);
527}
528
529void
530General_options::parse_script(const char*, const char* arg,
531 Command_line* cmdline)
532{
533 if (!read_commandline_script(arg, cmdline))
534 gold::gold_fatal(_("unable to parse script file %s"), arg);
535}
536
537void
538General_options::parse_version_script(const char*, const char* arg,
539 Command_line* cmdline)
540{
541 if (!read_version_script(arg, cmdline))
542 gold::gold_fatal(_("unable to parse version script file %s"), arg);
543}
544
545void
546General_options::parse_dynamic_list(const char*, const char* arg,
547 Command_line* cmdline)
548{
549 if (!read_dynamic_list(arg, cmdline, &this->dynamic_list_))
550 gold::gold_fatal(_("unable to parse dynamic-list script file %s"), arg);
551}
552
553void
554General_options::parse_start_group(const char*, const char*,
555 Command_line* cmdline)
556{
557 cmdline->inputs().start_group();
558}
559
560void
561General_options::parse_end_group(const char*, const char*,
562 Command_line* cmdline)
563{
564 cmdline->inputs().end_group();
565}
566
567void
568General_options::parse_start_lib(const char*, const char*,
569 Command_line* cmdline)
570{
571 cmdline->inputs().start_lib(cmdline->position_dependent_options());
572}
573
574void
575General_options::parse_end_lib(const char*, const char*,
576 Command_line* cmdline)
577{
578 cmdline->inputs().end_lib();
579}
580
581// The function add_excluded_libs() in ld/ldlang.c of GNU ld breaks up a list
582// of names separated by commas or colons and puts them in a linked list.
583// We implement the same parsing of names here but store names in an unordered
584// map to speed up searching of names.
585
586void
587General_options::parse_exclude_libs(const char*, const char* arg,
588 Command_line*)
589{
590 const char* p = arg;
591
592 while (*p != '\0')
593 {
594 size_t length = strcspn(p, ",:");
595 this->excluded_libs_.insert(std::string(p, length));
596 p += (p[length] ? length + 1 : length);
597 }
598}
599
600// The checking logic is based on the function check_excluded_libs() in
601// ld/ldlang.c of GNU ld but our implementation is different because we use
602// an unordered map instead of a linked list, which is what GNU ld uses. GNU
603// ld searches sequentially in the excluded libs list. For a given archive,
604// a match is found if the archive's name matches exactly one of the list
605// entry or if the archive's name is of the form FOO.a and FOO matches exactly
606// one of the list entry. An entry "ALL" in the list is considered as a
607// wild-card and matches any given name.
608
609bool
610General_options::check_excluded_libs(const std::string &name) const
611{
612 Unordered_set<std::string>::const_iterator p;
613
614 // Exit early for the most common case.
615 if (excluded_libs_.empty())
616 return false;
617
618 // If we see "ALL", all archives are excluded from automatic export.
619 p = excluded_libs_.find(std::string("ALL"));
620 if (p != excluded_libs_.end())
621 return true;
622
623 // First strip off any directories in name.
624 const char* basename = lbasename(name.c_str());
625
626 // Try finding an exact match.
627 p = excluded_libs_.find(std::string(basename));
628 if (p != excluded_libs_.end())
629 return true;
630
631 // Try matching NAME without ".a" at the end.
632 size_t length = strlen(basename);
633 if ((length >= 2)
634 && (basename[length - 2] == '.')
635 && (basename[length - 1] == 'a'))
636 {
637 p = excluded_libs_.find(std::string(basename, length - 2));
638 if (p != excluded_libs_.end())
639 return true;
640 }
641
642 return false;
643}
644
645// Recognize input and output target names. The GNU linker accepts
646// these with --format and --oformat. This code is intended to be
647// minimally compatible. In practice for an ELF target this would be
648// the same target as the input files; that name always start with
649// "elf". Non-ELF targets would be "srec", "symbolsrec", "tekhex",
650// "binary", "ihex".
651
652General_options::Object_format
653General_options::string_to_object_format(const char* arg)
654{
655 if (strncmp(arg, "elf", 3) == 0)
656 return gold::General_options::OBJECT_FORMAT_ELF;
657 else if (strcmp(arg, "binary") == 0)
658 return gold::General_options::OBJECT_FORMAT_BINARY;
659 else
660 {
661 gold::gold_error(_("format '%s' not supported; treating as elf "
662 "(supported formats: elf, binary)"),
663 arg);
664 return gold::General_options::OBJECT_FORMAT_ELF;
665 }
666}
667
668void
669General_options::parse_fix_v4bx(const char*, const char*,
670 Command_line*)
671{
672 this->fix_v4bx_ = FIX_V4BX_REPLACE;
673}
674
675void
676General_options::parse_fix_v4bx_interworking(const char*, const char*,
677 Command_line*)
678{
679 this->fix_v4bx_ = FIX_V4BX_INTERWORKING;
680}
681
682void
683General_options::parse_EB(const char*, const char*, Command_line*)
684{
685 this->endianness_ = ENDIANNESS_BIG;
686}
687
688void
689General_options::parse_EL(const char*, const char*, Command_line*)
690{
691 this->endianness_ = ENDIANNESS_LITTLE;
692}
693
694} // End namespace gold.
695
696namespace
697{
698
699void
700usage()
701{
702 fprintf(stderr,
703 _("%s: use the --help option for usage information\n"),
704 gold::program_name);
705 ::exit(EXIT_FAILURE);
706}
707
708void
709usage(const char* msg, const char* opt)
710{
711 fprintf(stderr,
712 _("%s: %s: %s\n"),
713 gold::program_name, opt, msg);
714 usage();
715}
716
717// If the default sysroot is relocatable, try relocating it based on
718// the prefix FROM.
719
720static char*
721get_relative_sysroot(const char* from)
722{
723 char* path = make_relative_prefix(gold::program_name, from,
724 TARGET_SYSTEM_ROOT);
725 if (path != NULL)
726 {
727 struct stat s;
728 if (::stat(path, &s) == 0 && S_ISDIR(s.st_mode))
729 return path;
730 free(path);
731 }
732
733 return NULL;
734}
735
736// Return the default sysroot. This is set by the --with-sysroot
737// option to configure. Note we do not free the return value of
738// get_relative_sysroot, which is a small memory leak, but is
739// necessary since we store this pointer directly in General_options.
740
741static const char*
742get_default_sysroot()
743{
744 const char* sysroot = TARGET_SYSTEM_ROOT;
745 if (*sysroot == '\0')
746 return NULL;
747
748 if (TARGET_SYSTEM_ROOT_RELOCATABLE)
749 {
750 char* path = get_relative_sysroot(BINDIR);
751 if (path == NULL)
752 path = get_relative_sysroot(TOOLBINDIR);
753 if (path != NULL)
754 return path;
755 }
756
757 return sysroot;
758}
759
760// Parse a long option. Such options have the form
761// <-|--><option>[=arg]. If "=arg" is not present but the option
762// takes an argument, the next word is taken to the be the argument.
763// If equals_only is set, then only the <option>=<arg> form is
764// accepted, not the <option><space><arg> form. Returns a One_option
765// struct or NULL if argv[i] cannot be parsed as a long option. In
766// the not-NULL case, *arg is set to the option's argument (NULL if
767// the option takes no argument), and *i is advanced past this option.
768// NOTE: it is safe for argv and arg to point to the same place.
769gold::options::One_option*
770parse_long_option(int argc, const char** argv, bool equals_only,
771 const char** arg, int* i)
772{
773 const char* const this_argv = argv[*i];
774
775 const char* equals = strchr(this_argv, '=');
776 const char* option_start = this_argv + strspn(this_argv, "-");
777 std::string option(option_start,
778 equals ? equals - option_start : strlen(option_start));
779
780 gold::options::Option_map::iterator it
781 = gold::options::long_options->find(option);
782 if (it == gold::options::long_options->end())
783 return NULL;
784
785 gold::options::One_option* retval = it->second;
786
787 // If the dash-count doesn't match, we fail.
788 if (this_argv[0] != '-') // no dashes at all: had better be "-z <longopt>"
789 {
790 if (retval->dashes != gold::options::DASH_Z)
791 return NULL;
792 }
793 else if (this_argv[1] != '-') // one dash
794 {
795 if (retval->dashes != gold::options::ONE_DASH
796 && retval->dashes != gold::options::EXACTLY_ONE_DASH
797 && retval->dashes != gold::options::TWO_DASHES)
798 return NULL;
799 }
800 else // two dashes (or more!)
801 {
802 if (retval->dashes != gold::options::TWO_DASHES
803 && retval->dashes != gold::options::EXACTLY_TWO_DASHES
804 && retval->dashes != gold::options::ONE_DASH)
805 return NULL;
806 }
807
808 // Now that we know the option is good (or else bad in a way that
809 // will cause us to die), increment i to point past this argv.
810 ++(*i);
811
812 // Figure out the option's argument, if any.
813 if (!retval->takes_argument())
814 {
815 if (equals)
816 usage(_("unexpected argument"), this_argv);
817 else
818 *arg = NULL;
819 }
820 else
821 {
822 if (equals)
823 *arg = equals + 1;
824 else if (retval->takes_optional_argument())
825 *arg = retval->default_value;
826 else if (*i < argc && !equals_only)
827 *arg = argv[(*i)++];
828 else
829 usage(_("missing argument"), this_argv);
830 }
831
832 return retval;
833}
834
835// Parse a short option. Such options have the form -<option>[arg].
836// If "arg" is not present but the option takes an argument, the next
837// word is taken to the be the argument. If the option does not take
838// an argument, it may be followed by another short option. Returns a
839// One_option struct or NULL if argv[i] cannot be parsed as a short
840// option. In the not-NULL case, *arg is set to the option's argument
841// (NULL if the option takes no argument), and *i is advanced past
842// this option. This function keeps *i the same if we parsed a short
843// option that does not take an argument, that looks to be followed by
844// another short option in the same word.
845gold::options::One_option*
846parse_short_option(int argc, const char** argv, int pos_in_argv_i,
847 const char** arg, int* i)
848{
849 const char* const this_argv = argv[*i];
850
851 if (this_argv[0] != '-')
852 return NULL;
853
854 // We handle -z as a special case.
855 static gold::options::One_option dash_z("", gold::options::DASH_Z,
856 'z', "", NULL, "Z-OPTION", false,
857 NULL);
858 gold::options::One_option* retval = NULL;
859 if (this_argv[pos_in_argv_i] == 'z')
860 retval = &dash_z;
861 else
862 {
863 const int char_as_int = static_cast<int>(this_argv[pos_in_argv_i]);
864 if (char_as_int > 0 && char_as_int < 128)
865 retval = gold::options::short_options[char_as_int];
866 }
867
868 if (retval == NULL)
869 return NULL;
870
871 // Figure out the option's argument, if any.
872 if (!retval->takes_argument())
873 {
874 *arg = NULL;
875 // We only advance past this argument if it's the only one in argv.
876 if (this_argv[pos_in_argv_i + 1] == '\0')
877 ++(*i);
878 }
879 else
880 {
881 // If we take an argument, we'll eat up this entire argv entry.
882 ++(*i);
883 if (this_argv[pos_in_argv_i + 1] != '\0')
884 *arg = this_argv + pos_in_argv_i + 1;
885 else if (retval->takes_optional_argument())
886 *arg = retval->default_value;
887 else if (*i < argc)
888 *arg = argv[(*i)++];
889 else
890 usage(_("missing argument"), this_argv);
891 }
892
893 // If we're a -z option, we need to parse our argument as a
894 // long-option, e.g. "-z stacksize=8192".
895 if (retval == &dash_z)
896 {
897 int dummy_i = 0;
898 const char* dash_z_arg = *arg;
899 retval = parse_long_option(1, arg, true, arg, &dummy_i);
900 if (retval == NULL)
901 usage(_("unknown -z option"), dash_z_arg);
902 }
903
904 return retval;
905}
906
907} // End anonymous namespace.
908
909namespace gold
910{
911
912General_options::General_options()
913 : printed_version_(false),
914 execstack_status_(EXECSTACK_FROM_INPUT),
915 icf_status_(ICF_NONE),
916 static_(false),
917 do_demangle_(false),
918 plugins_(NULL),
919 dynamic_list_(),
920 incremental_mode_(INCREMENTAL_OFF),
921 incremental_disposition_(INCREMENTAL_STARTUP),
922 incremental_startup_disposition_(INCREMENTAL_CHECK),
923 implicit_incremental_(false),
924 excluded_libs_(),
925 symbols_to_retain_(),
926 section_starts_(),
927 fix_v4bx_(FIX_V4BX_NONE),
928 endianness_(ENDIANNESS_NOT_SET)
929{
930 // Turn off option registration once construction is complete.
931 gold::options::ready_to_register = false;
932}
933
934General_options::Object_format
935General_options::format_enum() const
936{
937 return General_options::string_to_object_format(this->format());
938}
939
940General_options::Object_format
941General_options::oformat_enum() const
942{
943 return General_options::string_to_object_format(this->oformat());
944}
945
946// Add the sysroot, if any, to the search paths.
947
948void
949General_options::add_sysroot()
950{
951 if (this->sysroot() == NULL || this->sysroot()[0] == '\0')
952 {
953 this->set_sysroot(get_default_sysroot());
954 if (this->sysroot() == NULL || this->sysroot()[0] == '\0')
955 return;
956 }
957
958 char* canonical_sysroot = lrealpath(this->sysroot());
959
960 for (Dir_list::iterator p = this->library_path_.value.begin();
961 p != this->library_path_.value.end();
962 ++p)
963 p->add_sysroot(this->sysroot(), canonical_sysroot);
964
965 free(canonical_sysroot);
966}
967
968// Return whether FILENAME is in a system directory.
969
970bool
971General_options::is_in_system_directory(const std::string& filename) const
972{
973 for (Dir_list::const_iterator p = this->library_path_.value.begin();
974 p != this->library_path_.value.end();
975 ++p)
976 {
977 // We use a straight string comparison rather than calling
978 // FILENAME_CMP because we are only interested in the cases
979 // where we found the file in a system directory, which means
980 // that we used the directory name as a prefix for a -L search.
981 if (p->is_system_directory()
982 && filename.compare(0, p->name().size(), p->name()) == 0)
983 return true;
984 }
985 return false;
986}
987
988// Add a plugin to the list of plugins.
989
990void
991General_options::add_plugin(const char* filename)
992{
993 if (this->plugins_ == NULL)
994 this->plugins_ = new Plugin_manager(*this);
995 this->plugins_->add_plugin(filename);
996}
997
998// Add a plugin option to a plugin.
999
1000void
1001General_options::add_plugin_option(const char* arg)
1002{
1003 if (this->plugins_ == NULL)
1004 gold_fatal("--plugin-opt requires --plugin.");
1005 this->plugins_->add_plugin_option(arg);
1006}
1007
1008// Set up variables and other state that isn't set up automatically by
1009// the parse routine, and ensure options don't contradict each other
1010// and are otherwise kosher.
1011
1012void
1013General_options::finalize()
1014{
1015 // Normalize the strip modifiers. They have a total order:
1016 // strip_all > strip_debug > strip_non_line > strip_debug_gdb.
1017 // If one is true, set all beneath it to true as well.
1018 if (this->strip_all())
1019 this->set_strip_debug(true);
1020 if (this->strip_debug())
1021 this->set_strip_debug_non_line(true);
1022 if (this->strip_debug_non_line())
1023 this->set_strip_debug_gdb(true);
1024
1025 if (this->Bshareable())
1026 this->set_shared(true);
1027
1028 // If the user specifies both -s and -r, convert the -s to -S.
1029 // -r requires us to keep externally visible symbols!
1030 if (this->strip_all() && this->relocatable())
1031 {
1032 this->set_strip_all(false);
1033 gold_assert(this->strip_debug());
1034 }
1035
1036 // For us, -dc and -dp are synonyms for --define-common.
1037 if (this->dc())
1038 this->set_define_common(true);
1039 if (this->dp())
1040 this->set_define_common(true);
1041
1042 // We also set --define-common if we're not relocatable, as long as
1043 // the user didn't explicitly ask for something different.
1044 if (!this->user_set_define_common())
1045 this->set_define_common(!this->relocatable());
1046
1047 // execstack_status_ is a three-state variable; update it based on
1048 // -z [no]execstack.
1049 if (this->execstack())
1050 this->set_execstack_status(EXECSTACK_YES);
1051 else if (this->noexecstack())
1052 this->set_execstack_status(EXECSTACK_NO);
1053
1054 // icf_status_ is a three-state variable; update it based on the
1055 // value of this->icf().
1056 if (strcmp(this->icf(), "none") == 0)
1057 this->set_icf_status(ICF_NONE);
1058 else if (strcmp(this->icf(), "safe") == 0)
1059 this->set_icf_status(ICF_SAFE);
1060 else
1061 this->set_icf_status(ICF_ALL);
1062
1063 // Handle the optional argument for --demangle.
1064 if (this->user_set_demangle())
1065 {
1066 this->set_do_demangle(true);
1067 const char* style = this->demangle();
1068 if (*style != '\0')
1069 {
1070 enum demangling_styles style_code;
1071
1072 style_code = cplus_demangle_name_to_style(style);
1073 if (style_code == unknown_demangling)
1074 gold_fatal("unknown demangling style '%s'", style);
1075 cplus_demangle_set_style(style_code);
1076 }
1077 }
1078 else if (this->user_set_no_demangle())
1079 this->set_do_demangle(false);
1080 else
1081 {
1082 // Testing COLLECT_NO_DEMANGLE makes our default demangling
1083 // behaviour identical to that of gcc's linker wrapper.
1084 this->set_do_demangle(getenv("COLLECT_NO_DEMANGLE") == NULL);
1085 }
1086
1087 // -M is equivalent to "-Map -".
1088 if (this->print_map() && !this->user_set_Map())
1089 {
1090 this->set_Map("-");
1091 this->set_user_set_Map();
1092 }
1093
1094 // Using -n or -N implies -static.
1095 if (this->nmagic() || this->omagic())
1096 this->set_static(true);
1097
1098 // If --thread_count is specified, it applies to
1099 // --thread-count-{initial,middle,final}, though it doesn't override
1100 // them.
1101 if (this->thread_count() > 0 && this->thread_count_initial() == 0)
1102 this->set_thread_count_initial(this->thread_count());
1103 if (this->thread_count() > 0 && this->thread_count_middle() == 0)
1104 this->set_thread_count_middle(this->thread_count());
1105 if (this->thread_count() > 0 && this->thread_count_final() == 0)
1106 this->set_thread_count_final(this->thread_count());
1107
1108 // Let's warn if you set the thread-count but we're going to ignore it.
1109#ifndef ENABLE_THREADS
1110 if (this->threads())
1111 {
1112 gold_warning(_("ignoring --threads: "
1113 "%s was compiled without thread support"),
1114 program_name);
1115 this->set_threads(false);
1116 }
1117 if (this->thread_count() > 0 || this->thread_count_initial() > 0
1118 || this->thread_count_middle() > 0 || this->thread_count_final() > 0)
1119 gold_warning(_("ignoring --thread-count: "
1120 "%s was compiled without thread support"),
1121 program_name);
1122#endif
1123
1124 if (this->user_set_Y())
1125 {
1126 std::string s = this->Y();
1127 if (s.compare(0, 2, "P,") == 0)
1128 s.erase(0, 2);
1129
1130 size_t pos = 0;
1131 size_t next_pos;
1132 do
1133 {
1134 next_pos = s.find(':', pos);
1135 size_t len = (next_pos == std::string::npos
1136 ? next_pos
1137 : next_pos - pos);
1138 if (len != 0)
1139 this->add_to_library_path_with_sysroot(s.substr(pos, len).c_str());
1140 pos = next_pos + 1;
1141 }
1142 while (next_pos != std::string::npos);
1143 }
1144 else if (!this->nostdlib())
1145 {
090a3931 1146 this->add_to_library_path_with_sysroot(USRDATA_PREFIX "/usr/lib");
dfe305e9
JM
1147 }
1148
1149 // Parse the contents of -retain-symbols-file into a set.
1150 if (this->retain_symbols_file())
1151 {
1152 std::ifstream in;
1153 in.open(this->retain_symbols_file());
1154 if (!in)
1155 gold_fatal(_("unable to open -retain-symbols-file file %s: %s"),
1156 this->retain_symbols_file(), strerror(errno));
1157 std::string line;
1158 std::getline(in, line); // this chops off the trailing \n, if any
1159 while (in)
1160 {
1161 if (!line.empty() && line[line.length() - 1] == '\r') // Windows
1162 line.resize(line.length() - 1);
1163 this->symbols_to_retain_.insert(line);
1164 std::getline(in, line);
1165 }
1166 }
1167
1168 // -Bgroup implies --unresolved-symbols=report-all.
1169 if (this->Bgroup() && !this->user_set_unresolved_symbols())
1170 this->set_unresolved_symbols("report-all");
1171
1172 // -shared implies --allow-shlib-undefined. Currently
1173 // ---allow-shlib-undefined controls warnings issued based on the
1174 // -symbol table. --unresolved-symbols controls warnings issued
1175 // -based on relocations.
1176 if (this->shared() && !this->user_set_allow_shlib_undefined())
1177 this->set_allow_shlib_undefined(true);
1178
1179 // Normalize library_path() by adding the sysroot to all directories
1180 // in the path, as appropriate.
1181 this->add_sysroot();
1182
1183 // Now that we've normalized the options, check for contradictory ones.
1184 if (this->shared() && this->is_static())
1185 gold_fatal(_("-shared and -static are incompatible"));
1186 if (this->shared() && this->pie())
1187 gold_fatal(_("-shared and -pie are incompatible"));
1188
1189 if (this->shared() && this->relocatable())
1190 gold_fatal(_("-shared and -r are incompatible"));
1191 if (this->pie() && this->relocatable())
1192 gold_fatal(_("-pie and -r are incompatible"));
1193
1194 if (!this->shared())
1195 {
1196 if (this->filter() != NULL)
1197 gold_fatal(_("-F/--filter may not used without -shared"));
1198 if (this->any_auxiliary())
1199 gold_fatal(_("-f/--auxiliary may not be used without -shared"));
1200 }
1201
1202 // TODO: implement support for -retain-symbols-file with -r, if needed.
1203 if (this->relocatable() && this->retain_symbols_file())
1204 gold_fatal(_("-retain-symbols-file does not yet work with -r"));
1205
1206 if (this->oformat_enum() != General_options::OBJECT_FORMAT_ELF
1207 && (this->shared()
1208 || this->pie()
1209 || this->relocatable()))
1210 gold_fatal(_("binary output format not compatible "
1211 "with -shared or -pie or -r"));
1212
1213 if (this->user_set_hash_bucket_empty_fraction()
1214 && (this->hash_bucket_empty_fraction() < 0.0
1215 || this->hash_bucket_empty_fraction() >= 1.0))
1216 gold_fatal(_("--hash-bucket-empty-fraction value %g out of range "
1217 "[0.0, 1.0)"),
1218 this->hash_bucket_empty_fraction());
1219
1220 if (this->implicit_incremental_ && this->incremental_mode_ == INCREMENTAL_OFF)
1221 gold_fatal(_("Options --incremental-changed, --incremental-unchanged, "
1222 "--incremental-unknown require the use of --incremental"));
1223
1224 // FIXME: we can/should be doing a lot more sanity checking here.
1225}
1226
1227// Search_directory methods.
1228
1229// This is called if we have a sysroot. Apply the sysroot if
1230// appropriate. Record whether the directory is in the sysroot.
1231
1232void
1233Search_directory::add_sysroot(const char* sysroot,
1234 const char* canonical_sysroot)
1235{
1236 gold_assert(*sysroot != '\0');
1237 if (this->put_in_sysroot_)
1238 {
1239 if (!IS_DIR_SEPARATOR(this->name_[0])
1240 && !IS_DIR_SEPARATOR(sysroot[strlen(sysroot) - 1]))
1241 this->name_ = '/' + this->name_;
1242 this->name_ = sysroot + this->name_;
1243 this->is_in_sysroot_ = true;
1244 }
1245 else
1246 {
1247 // Check whether this entry is in the sysroot. To do this
1248 // correctly, we need to use canonical names. Otherwise we will
1249 // get confused by the ../../.. paths that gcc tends to use.
1250 char* canonical_name = lrealpath(this->name_.c_str());
1251 int canonical_name_len = strlen(canonical_name);
1252 int canonical_sysroot_len = strlen(canonical_sysroot);
1253 if (canonical_name_len > canonical_sysroot_len
1254 && IS_DIR_SEPARATOR(canonical_name[canonical_sysroot_len]))
1255 {
1256 canonical_name[canonical_sysroot_len] = '\0';
1257 if (FILENAME_CMP(canonical_name, canonical_sysroot) == 0)
1258 this->is_in_sysroot_ = true;
1259 }
1260 free(canonical_name);
1261 }
1262}
1263
1264// Input_arguments methods.
1265
1266// Add a file to the list.
1267
1268Input_argument&
1269Input_arguments::add_file(Input_file_argument& file)
1270{
1271 file.set_arg_serial(++this->file_count_);
1272 if (this->in_group_)
1273 {
1274 gold_assert(!this->input_argument_list_.empty());
1275 gold_assert(this->input_argument_list_.back().is_group());
1276 return this->input_argument_list_.back().group()->add_file(file);
1277 }
1278 if (this->in_lib_)
1279 {
1280 gold_assert(!this->input_argument_list_.empty());
1281 gold_assert(this->input_argument_list_.back().is_lib());
1282 return this->input_argument_list_.back().lib()->add_file(file);
1283 }
1284 this->input_argument_list_.push_back(Input_argument(file));
1285 return this->input_argument_list_.back();
1286}
1287
1288// Start a group.
1289
1290void
1291Input_arguments::start_group()
1292{
1293 if (this->in_group_)
1294 gold_fatal(_("May not nest groups"));
1295 if (this->in_lib_)
1296 gold_fatal(_("may not nest groups in libraries"));
1297 Input_file_group* group = new Input_file_group();
1298 this->input_argument_list_.push_back(Input_argument(group));
1299 this->in_group_ = true;
1300}
1301
1302// End a group.
1303
1304void
1305Input_arguments::end_group()
1306{
1307 if (!this->in_group_)
1308 gold_fatal(_("Group end without group start"));
1309 this->in_group_ = false;
1310}
1311
1312// Start a lib.
1313
1314void
1315Input_arguments::start_lib(const Position_dependent_options& options)
1316{
1317 if (this->in_lib_)
1318 gold_fatal(_("may not nest libraries"));
1319 if (this->in_group_)
1320 gold_fatal(_("may not nest libraries in groups"));
1321 Input_file_lib* lib = new Input_file_lib(options);
1322 this->input_argument_list_.push_back(Input_argument(lib));
1323 this->in_lib_ = true;
1324}
1325
1326// End a lib.
1327
1328void
1329Input_arguments::end_lib()
1330{
1331 if (!this->in_lib_)
1332 gold_fatal(_("lib end without lib start"));
1333 this->in_lib_ = false;
1334}
1335
1336// Command_line options.
1337
1338Command_line::Command_line()
1339{
1340}
1341
1342// Pre_options is the hook that sets the ready_to_register flag.
1343
1344Command_line::Pre_options::Pre_options()
1345{
1346 gold::options::ready_to_register = true;
1347}
1348
1349// Process the command line options. For process_one_option, i is the
1350// index of argv to process next, and must be an option (that is,
1351// start with a dash). The return value is the index of the next
1352// option to process (i+1 or i+2, or argc to indicate processing is
1353// done). no_more_options is set to true if (and when) "--" is seen
1354// as an option.
1355
1356int
1357Command_line::process_one_option(int argc, const char** argv, int i,
1358 bool* no_more_options)
1359{
1360 gold_assert(argv[i][0] == '-' && !(*no_more_options));
1361
1362 // If we are reading "--", then just set no_more_options and return.
1363 if (argv[i][1] == '-' && argv[i][2] == '\0')
1364 {
1365 *no_more_options = true;
1366 return i + 1;
1367 }
1368
1369 int new_i = i;
1370 options::One_option* option = NULL;
1371 const char* arg = NULL;
1372
1373 // First, try to process argv as a long option.
1374 option = parse_long_option(argc, argv, false, &arg, &new_i);
1375 if (option)
1376 {
1377 option->reader->parse_to_value(argv[i], arg, this, &this->options_);
1378 return new_i;
1379 }
1380
1381 // Now, try to process argv as a short option. Since several short
1382 // options can be combined in one argv, we may have to parse a lot
1383 // until we're done reading this argv.
1384 int pos_in_argv_i = 1;
1385 while (new_i == i)
1386 {
1387 option = parse_short_option(argc, argv, pos_in_argv_i, &arg, &new_i);
1388 if (!option)
1389 break;
1390 option->reader->parse_to_value(argv[i], arg, this, &this->options_);
1391 ++pos_in_argv_i;
1392 }
1393 if (option)
1394 return new_i;
1395
1396 // I guess it's neither a long option nor a short option.
1397 usage(_("unknown option"), argv[i]);
1398 return argc;
1399}
1400
1401
1402void
1403Command_line::process(int argc, const char** argv)
1404{
1405 bool no_more_options = false;
1406 int i = 0;
1407 while (i < argc)
1408 {
1409 this->position_options_.copy_from_options(this->options());
1410 if (no_more_options || argv[i][0] != '-')
1411 {
1412 Input_file_argument file(argv[i],
1413 Input_file_argument::INPUT_FILE_TYPE_FILE,
1414 "", false, this->position_options_);
1415 this->inputs_.add_file(file);
1416 ++i;
1417 }
1418 else
1419 i = process_one_option(argc, argv, i, &no_more_options);
1420 }
1421
1422 if (this->inputs_.in_group())
1423 {
1424 fprintf(stderr, _("%s: missing group end\n"), program_name);
1425 usage();
1426 }
1427
1428 // Normalize the options and ensure they don't contradict each other.
1429 this->options_.finalize();
1430}
1431
1432// Finalize the version script options and return them.
1433
1434const Version_script_info&
1435Command_line::version_script()
1436{
1437 this->options_.finalize_dynamic_list();
1438 Version_script_info* vsi = this->script_options_.version_script_info();
1439 vsi->finalize();
1440 return *vsi;
1441}
1442
1443} // End namespace gold.