diff --git a/gold/compressed_output.cc b/gold/compressed_output.cc index 1eca021e71..e62eab2245 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 e37e2f157a..143c7dfbf1 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 fd7f3afb2f..1591cfb5c9 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 a5fd12c2ec..e4f9003b21 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 88f3db3062..5307d86cb2 100644 --- a/gold/options.cc +++ b/gold/options.cc @@ -23,6 +23,7 @@ #include "gold.h" #include +#include #include #include #include "filenames.h" @@ -30,127 +31,306 @@ #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; +void +One_option::register_option() +{ + registered_options.push_back(this); - // Long option dash control. This is ignored if long_option is - // NULL. - enum + // 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; + + // TWO_DASHES means that two dashes are preferred, but one is ok too. + if (!this->longname.empty()) + (*long_options)[this->longname] = this; + + 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; +} + +void +One_option::print() const +{ + bool comma = false; + printf(" "); + int len = 2; + if (this->shortname != '\0') { - // 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; + 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); + } + } - // 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 (len >= 30) + { + printf("\n"); + len = 0; + } + for (; len < 30; ++len) + std::putchar(' '); - // 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); + // TODO: if we're boolean, add " (default)" when appropriate. + printf("%s\n", this->helpstring); +} - // 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 +help() { - // The name of the option. - const char* name; + printf(_("Usage: %s [options] file...\nOptions:\n"), gold::program_name); - // The member function in General_options called to record an option - // which does not take an argument. - void (General_options::*set_noarg)(bool); + std::vector::const_iterator it; + for (it = registered_options.begin(); it != registered_options.end(); ++it) + (*it)->print(); +} - // The member function in General_options called to record an option - // which does take an argument. - void (General_options::*set_arg)(const char*); -}; - -// We have a separate table for --debug options. - -struct options::One_debug_option +// 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) { - // The name of the option. - const char* name; + *retval = true; +} - // The flags to turn on. - unsigned int debug_flags; -}; - -class options::Command_line_options +void +parse_uint(const char* option_name, const char* arg, int* retval) { - 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; -}; + 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); +} + +void +parse_uint64(const char* option_name, const char* arg, uint64_t *retval) +{ + 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++) + { + 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()); +} + +} // End namespace options. + +// Define the handler for "special" options (set via DEFINE_special). + +void +General_options::parse_help(const char*, const char*, Command_line*) +{ + options::help(); + ::exit(EXIT_SUCCESS); +} + +void +General_options::parse_version(const char* opt, const char*, Command_line*) +{ + gold::print_version(opt[0] == '-' && opt[1] == 'v'); + ::exit(EXIT_SUCCESS); +} + +void +General_options::parse_Bstatic(const char*, const char*, Command_line*) +{ + this->set_Bdynamic(false); +} + +void +General_options::parse_defsym(const char*, const char* arg, + Command_line* cmdline) +{ + cmdline->script_options().define_symbol(arg); +} + +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) +{ + struct stat s; + if (::stat(arg, &s) != 0 || S_ISDIR(s.st_mode)) + this->add_to_rpath(arg); + else + this->parse_just_symbols(option, arg, cmdline); +} + +void +General_options::parse_just_symbols(const char*, const char* arg, + Command_line* cmdline) +{ + Input_file_argument file(arg, false, "", true, *this); + cmdline->inputs().add_file(file); +} + +void +General_options::parse_static(const char*, const char*, Command_line*) +{ + this->set_static(true); +} + +void +General_options::parse_script(const char*, const char* arg, + Command_line* cmdline) +{ + if (!read_commandline_script(arg, cmdline)) + gold::gold_fatal(_("unable to parse script file %s"), arg); +} + +void +General_options::parse_version_script(const char*, const char* arg, + Command_line* cmdline) +{ + if (!read_version_script(arg, cmdline)) + gold::gold_fatal(_("unable to parse version script file %s"), arg); +} + +void +General_options::parse_start_group(const char*, const char*, + Command_line* cmdline) +{ + cmdline->inputs().start_group(); +} + +void +General_options::parse_end_group(const char*, const char*, + Command_line* cmdline) +{ + cmdline->inputs().end_group(); +} } // End namespace gold. namespace { +void +usage() +{ + fprintf(stderr, + _("%s: use the --help option for usage information\n"), + gold::program_name); + ::exit(EXIT_FAILURE); +} + +void +usage(const char* msg, const char *opt) +{ + fprintf(stderr, + _("%s: %s: %s\n"), + gold::program_name, opt, msg); + usage(); +} + // 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. +// "binary", "ihex". gold::General_options::Object_format string_to_object_format(const char* arg) @@ -162,218 +342,12 @@ string_to_object_format(const char* arg) else { gold::gold_error(_("format '%s' not supported " - "(supported formats: elf, binary)"), - arg); + "(supported formats: elf, binary)"), + arg); return gold::General_options::OBJECT_FORMAT_ELF; } } -// Handle the special -defsym option, which defines a symbol. - -int -add_to_defsym(int argc, char** argv, char* arg, bool long_option, - gold::Command_line* cmdline) -{ - int ret; - const char* val = cmdline->get_special_argument("defsym", argc, argv, arg, - long_option, &ret); - cmdline->script_options().define_symbol(val); - return ret; -} - -// Handle the special -l option, which adds an input file. - -int -library(int argc, char** argv, char* arg, bool long_option, - gold::Command_line* cmdline) -{ - return cmdline->process_l_option(argc, argv, arg, long_option); -} - -// 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. - -int -handle_r_option(int argc, char** argv, char* arg, bool long_option, - gold::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); - else - cmdline->add_just_symbols_file(val); - return ret; -} - -// Handle the --just-symbols option. - -int -handle_just_symbols_option(int argc, char** argv, char* arg, - bool long_option, gold::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; -} - -// 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) -{ - 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; -} - -// 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) -{ - 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; -} - -// Handle the special --start-group option. - -int -start_group(int, char**, char* arg, bool, gold::Command_line* cmdline) -{ - cmdline->start_group(arg); - return 1; -} - -// Handle the special --end-group option. - -int -end_group(int, char**, char* arg, bool, gold::Command_line* cmdline) -{ - cmdline->end_group(arg); - return 1; -} - -// Report usage information for ld --help, and exit. - -int -help(int, char**, char*, bool, gold::Command_line*) -{ - 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); - - return 0; -} - -// Report version information. - -int -version(int, char**, char* opt, bool, gold::Command_line*) -{ - gold::print_version(opt[0] == 'v' && opt[1] == '\0'); - ::exit(EXIT_SUCCESS); - return 0; -} - // If the default sysroot is relocatable, try relocating it based on // the prefix FROM. @@ -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; } +// Parse a long option. Such options have the form +// <-|-->