From ee1fe73e110f7009719b6befefd9fabe94672931 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 4 Mar 2008 23:10:38 +0000 Subject: From Craig Silverstein: rework option handling to make it easier to add a new option. --- gold/compressed_output.cc | 2 +- gold/debug.h | 19 + gold/layout.cc | 2 +- gold/main.cc | 2 +- gold/options.cc | 1511 ++++++++++++++++----------------------------- gold/options.h | 1238 ++++++++++++++++++------------------- gold/parameters.cc | 6 +- gold/script.cc | 2 +- 8 files changed, 1150 insertions(+), 1632 deletions(-) (limited to 'gold') diff --git a/gold/compressed_output.cc b/gold/compressed_output.cc index 1eca021..e62eab2 100644 --- a/gold/compressed_output.cc +++ b/gold/compressed_output.cc @@ -112,7 +112,7 @@ Output_compressed_section::set_final_data_size() this->write_to_postprocessing_buffer(); bool success = false; - if (this->options_->zlib_compress_debug_sections()) + if (strcmp(this->options_->compress_debug_sections(), "zlib") == 0) success = zlib_compress(uncompressed_data, uncompressed_size, &this->data_, &compressed_size); if (success) diff --git a/gold/debug.h b/gold/debug.h index e37e2f1..143c7df 100644 --- a/gold/debug.h +++ b/gold/debug.h @@ -36,6 +36,25 @@ const int DEBUG_SCRIPT = 2; const int DEBUG_ALL = DEBUG_TASK | DEBUG_SCRIPT; +// Convert a debug string to the appropriate enum. +inline int +debug_string_to_enum(const char* arg) +{ + static const struct { const char* name; int value; } + debug_options[] = + { + { "task", DEBUG_TASK }, + { "script", DEBUG_SCRIPT }, + { "all", DEBUG_ALL } + }; + + int retval = 0; + for (size_t i = 0; i < sizeof(debug_options) / sizeof(*debug_options); ++i) + if (strstr(arg, debug_options[i].name)) + retval |= debug_options[i].value; + return retval; +} + // Print a debug message if TYPE is enabled. This is a macro so that // we only evaluate the arguments if necessary. diff --git a/gold/layout.cc b/gold/layout.cc index fd7f3af..1591cfb 100644 --- a/gold/layout.cc +++ b/gold/layout.cc @@ -612,7 +612,7 @@ Layout::make_output_section(const char* name, elfcpp::Elf_Word type, { Output_section* os; if ((flags & elfcpp::SHF_ALLOC) == 0 - && this->options_.compress_debug_sections() + && strcmp(this->options_.compress_debug_sections(), "none") != 0 && is_compressible_debug_section(name)) os = new Output_compressed_section(&this->options_, name, type, flags); else diff --git a/gold/main.cc b/gold/main.cc index a5fd12c..e4f9003 100644 --- a/gold/main.cc +++ b/gold/main.cc @@ -149,7 +149,7 @@ main(int argc, char** argv) // Handle the command line options. Command_line command_line; - command_line.process(argc - 1, argv + 1); + command_line.process(argc - 1, const_cast(argv + 1)); long start_time = 0; if (command_line.options().stats()) diff --git a/gold/options.cc b/gold/options.cc index 88f3db3..5307d86 100644 --- a/gold/options.cc +++ b/gold/options.cc @@ -23,6 +23,7 @@ #include "gold.h" #include +#include #include #include #include "filenames.h" @@ -30,348 +31,321 @@ #include "debug.h" #include "script.h" +#include "target-select.h" #include "options.h" namespace gold { -// The information we keep for a single command line option. +General_options +Position_dependent_options::default_options_; -struct options::One_option +namespace options { - // The single character option name, or '\0' if this is only a long - // option. - char short_option; - // The long option name, or NULL if this is only a short option. - const char* long_option; +// This global variable is set up as General_options is constructed. +static std::vector registered_options; - // Description of the option for --help output, or NULL if there is none. - const char* doc; +// These are set up at the same time -- the variables that accept one +// dash, two, or require -z. A single variable may be in more than +// one of thes data structures. +typedef Unordered_map Option_map; +static Option_map* long_options = NULL; +static One_option* short_options[128]; - // How to print the option name in --help output, or NULL to use the - // default. - const char* help_output; - - // Long option dash control. This is ignored if long_option is - // NULL. - enum - { - // Long option normally takes one dash; two dashes are also - // accepted. - ONE_DASH, - // Long option normally takes two dashes; one dash is also - // accepted. - TWO_DASHES, - // Long option always takes two dashes. - EXACTLY_TWO_DASHES - } dash; - - // Function for special handling, or NULL. Returns the number of - // arguments to skip. This will normally be at least 1, but it may - // be 0 if this function changes *argv. ARG points to the location - // in *ARGV where the option starts, which may be helpful for a - // short option. - int (*special)(int argc, char** argv, char *arg, bool long_option, - Command_line*); - - // If this is a position independent option which does not take an - // argument, this is the member function to call to record it. (In - // this file, the bool will always be 'true' to indicate the option - // is set.) - void (General_options::*general_noarg)(bool); - - // If this is a position independent function which takes an - // argument, this is the member function to call to record it. - void (General_options::*general_arg)(const char*); - - // If this is a position dependent option which does not take an - // argument, this is the member function to call to record it. (In - // this file, the bool will always be 'true' to indicate the option - // is set.) - void (Position_dependent_options::*dependent_noarg)(bool); - - // If this is a position dependent option which takes an argument, - // this is the member function to record it. - void (Position_dependent_options::*dependent_arg)(const char*); - - // Return whether this option takes an argument. - bool - takes_argument() const - { return this->general_arg != NULL || this->dependent_arg != NULL; } -}; - -// We have a separate table for -z options. - -struct options::One_z_option +void +One_option::register_option() { - // The name of the option. - const char* name; + registered_options.push_back(this); - // The member function in General_options called to record an option - // which does not take an argument. - void (General_options::*set_noarg)(bool); + // We can't make long_options a static Option_map because we can't + // guarantee that will be initialized before register_option() is + // first called. + if (long_options == NULL) + long_options = new Option_map; - // The member function in General_options called to record an option - // which does take an argument. - void (General_options::*set_arg)(const char*); -}; + // TWO_DASHES means that two dashes are preferred, but one is ok too. + if (!this->longname.empty()) + (*long_options)[this->longname] = this; -// We have a separate table for --debug options. + const int shortname_as_int = static_cast(this->shortname); + gold_assert(shortname_as_int >= 0 && shortname_as_int < 128); + if (this->shortname != '\0') + short_options[shortname_as_int] = this; +} -struct options::One_debug_option +void +One_option::print() const { - // The name of the option. - const char* name; + bool comma = false; + printf(" "); + int len = 2; + if (this->shortname != '\0') + { + len += printf("-%c", this->shortname); + if (this->helparg) + { + // -z takes long-names only. + gold_assert(this->dashes != DASH_Z); + len += printf(" %s", this->helparg); + } + comma = true; + } + if (!this->longname.empty() + && !(this->longname[0] == this->shortname + && this->longname[1] == '\0')) + { + if (comma) + len += printf(", "); + switch (this->dashes) + { + case options::ONE_DASH: case options::EXACTLY_ONE_DASH: + len += printf("-"); + break; + case options::TWO_DASHES: case options::EXACTLY_TWO_DASHES: + len += printf("--"); + break; + case options::DASH_Z: + len += printf("-z "); + break; + default: + gold_unreachable(); + } + len += printf("%s", this->longname.c_str()); + if (this->helparg) + { + // For most options, we print "--frob FOO". But for -z + // we print "-z frob=FOO". + len += printf("%c%s", this->dashes == options::DASH_Z ? '=' : ' ', + this->helparg); + } + } + + if (len >= 30) + { + printf("\n"); + len = 0; + } + for (; len < 30; ++len) + std::putchar(' '); - // The flags to turn on. - unsigned int debug_flags; -}; + // TODO: if we're boolean, add " (default)" when appropriate. + printf("%s\n", this->helpstring); +} -class options::Command_line_options +void +help() { - public: - static const One_option options[]; - static const int options_size; - static const One_z_option z_options[]; - static const int z_options_size; - static const One_debug_option debug_options[]; - static const int debug_options_size; -}; + printf(_("Usage: %s [options] file...\nOptions:\n"), gold::program_name); -} // End namespace gold. + std::vector::const_iterator it; + for (it = registered_options.begin(); it != registered_options.end(); ++it) + (*it)->print(); +} -namespace +// For bool, arg will be NULL (boolean options take no argument); +// we always just set to true. +void +parse_bool(const char*, const char*, bool* retval) { + *retval = true; +} -// Recognize input and output target names. The GNU linker accepts -// these with --format and --oformat. This code is intended to be -// minimally compatible. In practice for an ELF target this would be -// the same target as the input files; that name always start with -// "elf". Non-ELF targets would be "srec", "symbolsrec", "tekhex", -// "binary", "ihex". See also -// General_options::default_target_settings. +void +parse_uint(const char* option_name, const char* arg, int* retval) +{ + char* endptr; + *retval = strtol(arg, &endptr, 0); + if (*endptr != '\0' || retval < 0) + gold_fatal(_("%s: invalid option value (expected an integer): %s"), + option_name, arg); +} -gold::General_options::Object_format -string_to_object_format(const char* arg) +void +parse_uint64(const char* option_name, const char* arg, uint64_t *retval) { - if (strncmp(arg, "elf", 3) == 0) - return gold::General_options::OBJECT_FORMAT_ELF; - else if (strcmp(arg, "binary") == 0) - return gold::General_options::OBJECT_FORMAT_BINARY; - else + char* endptr; + *retval = strtoull(arg, &endptr, 0); + if (*endptr != '\0') + gold_fatal(_("%s: invalid option value (expected an integer): %s"), + option_name, arg); +} + +void +parse_string(const char* option_name, const char* arg, const char** retval) +{ + if (*arg == '\0') + gold_fatal(_("%s: must take a non-empty argument"), option_name); + *retval = arg; +} + +void +parse_dirlist(const char*, const char* arg, Dir_list* retval) +{ + retval->push_back(Search_directory(arg, false)); +} + +void +parse_choices(const char* option_name, const char* arg, const char** retval, + const char* choices[], int num_choices) +{ + for (int i = 0; i < num_choices; i++) + if (strcmp(choices[i], arg) == 0) + { + *retval = arg; + return; + } + + // If we get here, the user did not enter a valid choice, so we die. + std::string choices_list; + for (int i = 0; i < num_choices; i++) { - gold::gold_error(_("format '%s' not supported " - "(supported formats: elf, binary)"), - arg); - return gold::General_options::OBJECT_FORMAT_ELF; + choices_list += choices[i]; + if (i != num_choices - 1) + choices_list += ", "; } + gold_fatal(_("%s: must take one of the following arguments: %s"), + option_name, choices_list.c_str()); } -// Handle the special -defsym option, which defines a symbol. +} // End namespace options. -int -add_to_defsym(int argc, char** argv, char* arg, bool long_option, - gold::Command_line* cmdline) +// Define the handler for "special" options (set via DEFINE_special). + +void +General_options::parse_help(const char*, const char*, Command_line*) { - int ret; - const char* val = cmdline->get_special_argument("defsym", argc, argv, arg, - long_option, &ret); - cmdline->script_options().define_symbol(val); - return ret; + options::help(); + ::exit(EXIT_SUCCESS); } -// Handle the special -l option, which adds an input file. +void +General_options::parse_version(const char* opt, const char*, Command_line*) +{ + gold::print_version(opt[0] == '-' && opt[1] == 'v'); + ::exit(EXIT_SUCCESS); +} -int -library(int argc, char** argv, char* arg, bool long_option, - gold::Command_line* cmdline) +void +General_options::parse_Bstatic(const char*, const char*, Command_line*) { - return cmdline->process_l_option(argc, argv, arg, long_option); + this->set_Bdynamic(false); } -// Handle the -R option. Historically the GNU linker made -R a -// synonym for --just-symbols. ELF linkers have traditionally made -R -// a synonym for -rpath. When ELF support was added to the GNU -// linker, -R was changed to switch based on the argument: if the -// argument is an ordinary file, we treat it as --just-symbols, -// otherwise we treat it as -rpath. We need to be compatible with -// this, because existing build scripts rely on it. +void +General_options::parse_defsym(const char*, const char* arg, + Command_line* cmdline) +{ + cmdline->script_options().define_symbol(arg); +} -int -handle_r_option(int argc, char** argv, char* arg, bool long_option, - gold::Command_line* cmdline) +void +General_options::parse_library(const char*, const char* arg, + Command_line* cmdline) +{ + Input_file_argument file(arg, true, "", false, *this); + cmdline->inputs().add_file(file); +} + +void +General_options::parse_R(const char* option, const char* arg, + Command_line* cmdline) { - int ret; - const char* val = cmdline->get_special_argument("R", argc, argv, arg, - long_option, &ret); struct stat s; - if (::stat(val, &s) != 0 || S_ISDIR(s.st_mode)) - cmdline->add_to_rpath(val); + if (::stat(arg, &s) != 0 || S_ISDIR(s.st_mode)) + this->add_to_rpath(arg); else - cmdline->add_just_symbols_file(val); - return ret; + this->parse_just_symbols(option, arg, cmdline); } -// Handle the --just-symbols option. - -int -handle_just_symbols_option(int argc, char** argv, char* arg, - bool long_option, gold::Command_line* cmdline) +void +General_options::parse_just_symbols(const char*, const char* arg, + Command_line* cmdline) { - int ret; - const char* val = cmdline->get_special_argument("just-symbols", argc, argv, - arg, long_option, &ret); - cmdline->add_just_symbols_file(val); - return ret; + Input_file_argument file(arg, false, "", true, *this); + cmdline->inputs().add_file(file); } -// Handle the special -T/--script option, which reads a linker script. - -int -invoke_script(int argc, char** argv, char* arg, bool long_option, - gold::Command_line* cmdline) +void +General_options::parse_static(const char*, const char*, Command_line*) { - int ret; - const char* script_name = cmdline->get_special_argument("script", argc, argv, - arg, long_option, - &ret); - if (!read_commandline_script(script_name, cmdline)) - gold::gold_fatal(_("unable to parse script file %s"), script_name); - return ret; + this->set_static(true); } -// Handle the special --version-script option, which reads a version script. - -int -invoke_version_script(int argc, char** argv, char* arg, bool long_option, - gold::Command_line* cmdline) +void +General_options::parse_script(const char*, const char* arg, + Command_line* cmdline) { - int ret; - const char* script_name = cmdline->get_special_argument("version-script", - argc, argv, - arg, long_option, - &ret); - if (!read_version_script(script_name, cmdline)) - gold::gold_fatal(_("unable to parse version script file %s"), script_name); - return ret; + if (!read_commandline_script(arg, cmdline)) + gold::gold_fatal(_("unable to parse script file %s"), arg); } -// Handle the special --start-group option. - -int -start_group(int, char**, char* arg, bool, gold::Command_line* cmdline) +void +General_options::parse_version_script(const char*, const char* arg, + Command_line* cmdline) { - cmdline->start_group(arg); - return 1; + if (!read_version_script(arg, cmdline)) + gold::gold_fatal(_("unable to parse version script file %s"), arg); } -// Handle the special --end-group option. +void +General_options::parse_start_group(const char*, const char*, + Command_line* cmdline) +{ + cmdline->inputs().start_group(); +} -int -end_group(int, char**, char* arg, bool, gold::Command_line* cmdline) +void +General_options::parse_end_group(const char*, const char*, + Command_line* cmdline) { - cmdline->end_group(arg); - return 1; + cmdline->inputs().end_group(); } -// Report usage information for ld --help, and exit. +} // End namespace gold. -int -help(int, char**, char*, bool, gold::Command_line*) +namespace { - printf(_("Usage: %s [options] file...\nOptions:\n"), gold::program_name); - const int options_size = gold::options::Command_line_options::options_size; - const gold::options::One_option* options = - gold::options::Command_line_options::options; - for (int i = 0; i < options_size; ++i) - { - if (options[i].doc == NULL) - continue; - - printf(" "); - int len = 2; - bool comma = false; - - int j = i; - do - { - if (options[j].help_output != NULL) - { - if (comma) - { - printf(", "); - len += 2; - } - printf(options[j].help_output); - len += std::strlen(options[j].help_output); - comma = true; - } - else - { - if (options[j].short_option != '\0') - { - if (comma) - { - printf(", "); - len += 2; - } - printf("-%c", options[j].short_option); - len += 2; - comma = true; - } - - if (options[j].long_option != NULL) - { - if (comma) - { - printf(", "); - len += 2; - } - if (options[j].dash == gold::options::One_option::ONE_DASH) - { - printf("-"); - ++len; - } - else - { - printf("--"); - len += 2; - } - printf("%s", options[j].long_option); - len += std::strlen(options[j].long_option); - comma = true; - } - } - ++j; - } - while (j < options_size && options[j].doc == NULL); - - if (len >= 30) - { - printf("\n"); - len = 0; - } - for (; len < 30; ++len) - std::putchar(' '); - - std::puts(options[i].doc); - } - - ::exit(EXIT_SUCCESS); +void +usage() +{ + fprintf(stderr, + _("%s: use the --help option for usage information\n"), + gold::program_name); + ::exit(EXIT_FAILURE); +} - return 0; +void +usage(const char* msg, const char *opt) +{ + fprintf(stderr, + _("%s: %s: %s\n"), + gold::program_name, opt, msg); + usage(); } -// Report version information. +// Recognize input and output target names. The GNU linker accepts +// these with --format and --oformat. This code is intended to be +// minimally compatible. In practice for an ELF target this would be +// the same target as the input files; that name always start with +// "elf". Non-ELF targets would be "srec", "symbolsrec", "tekhex", +// "binary", "ihex". -int -version(int, char**, char* opt, bool, gold::Command_line*) +gold::General_options::Object_format +string_to_object_format(const char* arg) { - gold::print_version(opt[0] == 'v' && opt[1] == '\0'); - ::exit(EXIT_SUCCESS); - return 0; + if (strncmp(arg, "elf", 3) == 0) + return gold::General_options::OBJECT_FORMAT_ELF; + else if (strcmp(arg, "binary") == 0) + return gold::General_options::OBJECT_FORMAT_BINARY; + else + { + gold::gold_error(_("format '%s' not supported " + "(supported formats: elf, binary)"), + arg); + return gold::General_options::OBJECT_FORMAT_ELF; + } } // If the default sysroot is relocatable, try relocating it based on @@ -381,12 +355,12 @@ char* get_relative_sysroot(const char* from) { char* path = make_relative_prefix(gold::program_name, from, - TARGET_SYSTEM_ROOT); + TARGET_SYSTEM_ROOT); if (path != NULL) { struct stat s; if (::stat(path, &s) == 0 && S_ISDIR(s.st_mode)) - return path; + return path; free(path); } @@ -394,402 +368,191 @@ get_relative_sysroot(const char* from) } // Return the default sysroot. This is set by the --with-sysroot -// option to configure. +// option to configure. Note we do not free the return value of +// get_relative_sysroot, which is a small memory leak, but is +// necessary since we store this pointer directly in General_options. -std::string +const char* get_default_sysroot() { const char* sysroot = TARGET_SYSTEM_ROOT; if (*sysroot == '\0') - return ""; + return NULL; if (TARGET_SYSTEM_ROOT_RELOCATABLE) { - char* path = get_relative_sysroot (BINDIR); + char* path = get_relative_sysroot(BINDIR); if (path == NULL) - path = get_relative_sysroot (TOOLBINDIR); + path = get_relative_sysroot(TOOLBINDIR); if (path != NULL) - { - std::string ret = path; - free(path); - return ret; - } + return path; } return sysroot; } -} // End anonymous namespace. - -namespace gold +// Parse a long option. Such options have the form +// <-|-->