From b7209cb4ed7852044e3ec55daec11e9f693e401c Mon Sep 17 00:00:00 2001 From: Fred Fish Date: Tue, 30 Oct 2001 04:05:36 +0000 Subject: Changes approved by kev@cygnus.com, ezannoni@cygnus.com, eliz@is.elta.co.il. Changelog: 2001-10-27 Fred Fish * symfile.c (auto_solib_add): Update comment to note that this variable is now just used as a boolean to control shlib autoloading, and clarify when it is used. * symfile.h (auto_solib_add): Ditto. * symfile.c (auto_solib_limit): New variable that holds the autoloading threshold instead of overloading auto_solib_add. * symfile.h (auto_solib_limit): Ditto. * irix5-nat.c (_initialize_solib): Change auto-solib-add variable from var_zinteger to var_boolean and update help. * osfsolib.c (_initialize_solib): Ditto. * pa64solib.c (_initialize_pa64_solib): Ditto. * solib.c (_initialize_solib): Ditto. * somsolib.c (_initialize_som_solib): Ditto. * xcoffsolib.c (_initialize_solib): Ditto. * pa64solib.c (pa64_solib_total_st_size): Update comment to note that the new auto_solib_limit variable is used instead of overloading auto_solib_add variable. (_initialize_pa64_solib): Ditto. * somsolib.c (som_solib_total_st_size): Ditto. (_initialize_som_solib): Ditto. * pa64solib.c (_initialize_pa64_solib): Add new set/show commands for auto-solib-limit variable. * somsolib.c (_initialize_som_solib): Ditto * pa64solib.c (add_to_solist): Check that auto_solib_add is set and use auto_solib_limit as the threshold size instead of auto_solib_add. * somsolib.c (som_solib_add): Ditto, and also change warning text about size threshold exceeded. doc/ChangeLog: 2001-10-28 Fred Fish * gdb.texinfo (auto-solib-add): Change docs to match implementation change. (auto-solib-limit): Add docs for new variable. --- gdb/ChangeLog | 36 +++++++++++++++++++++++++++++++ gdb/doc/ChangeLog | 6 ++++++ gdb/doc/gdb.texinfo | 54 +++++++++++++++++++++++++++++++++++----------- gdb/irix5-nat.c | 10 ++++----- gdb/osfsolib.c | 10 ++++----- gdb/pa64solib.c | 62 +++++++++++++++++++++++++++++++---------------------- gdb/solib.c | 10 ++++----- gdb/somsolib.c | 57 +++++++++++++++++++++++++++--------------------- gdb/symfile.c | 36 +++++++++++++++---------------- gdb/symfile.h | 27 +++++++++++++++-------- gdb/xcoffsolib.c | 10 ++++----- 11 files changed, 208 insertions(+), 110 deletions(-) (limited to 'gdb') diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 8335659..cdbd531 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,39 @@ +2001-10-27 Fred Fish + + * symfile.c (auto_solib_add): Update comment to note that + this variable is now just used as a boolean to control shlib + autoloading, and clarify when it is used. + * symfile.h (auto_solib_add): Ditto. + + * symfile.c (auto_solib_limit): New variable that holds the + autoloading threshold instead of overloading auto_solib_add. + * symfile.h (auto_solib_limit): Ditto. + + * irix5-nat.c (_initialize_solib): Change auto-solib-add + variable from var_zinteger to var_boolean and update help. + * osfsolib.c (_initialize_solib): Ditto. + * pa64solib.c (_initialize_pa64_solib): Ditto. + * solib.c (_initialize_solib): Ditto. + * somsolib.c (_initialize_som_solib): Ditto. + * xcoffsolib.c (_initialize_solib): Ditto. + + * pa64solib.c (pa64_solib_total_st_size): Update comment to + note that the new auto_solib_limit variable is used instead + of overloading auto_solib_add variable. + (_initialize_pa64_solib): Ditto. + * somsolib.c (som_solib_total_st_size): Ditto. + (_initialize_som_solib): Ditto. + + * pa64solib.c (_initialize_pa64_solib): Add new set/show + commands for auto-solib-limit variable. + * somsolib.c (_initialize_som_solib): Ditto + + * pa64solib.c (add_to_solist): Check that auto_solib_add is + set and use auto_solib_limit as the threshold size instead + of auto_solib_add. + * somsolib.c (som_solib_add): Ditto, and also change warning + text about size threshold exceeded. + 2001-10-21 Mark Kettenis * config/i386/tm-i386v.h: Don't include "regcache.h". diff --git a/gdb/doc/ChangeLog b/gdb/doc/ChangeLog index 86ea966..38d8abd 100644 --- a/gdb/doc/ChangeLog +++ b/gdb/doc/ChangeLog @@ -1,3 +1,9 @@ +2001-10-28 Fred Fish + + * gdb.texinfo (auto-solib-add): Change docs to match + implementation change. + (auto-solib-limit): Add docs for new variable. + 2001-10-15 Andrew Cagney * gdbint.texinfo (Target Architecture Definition): Function diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index b40de03..d468977 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -8965,6 +8965,31 @@ automatically loads the symbols at the time of the @code{shl_load} call. @c FIXME...symbols---eg in a break cmd---assuming they are from a shared @c FIXME...lib; check this from time to time when updating manual +There are times, however, when you may wish to not automatically load +symbol definitions from shared libraries, such as when they are +particularly large or there are many of them. + +To control the automatic loading of shared library symbols, use the +commands: + +@table @code +@kindex set auto-solib-add +@item set auto-solib-add @var{mode} +If @var{mode} is @code{on}, symbols from all shared object libraries +will be loaded automatically when the inferior begins execution, you +attach to an independently started inferior, or when the dynamic linker +informs @value{GDBN} that a new library has been loaded. If @var{mode} +is @code{off}, symbols must be loaded manually, using the +@code{sharedlibrary} command. The default value is @code{on}. + +@kindex show auto-solib-add +@item show auto-solib-add +Display the current autoloading mode. +@end table + +To explicitly load shared library symbols, use the @code{sharedlibrary} +command: + @table @code @kindex info sharedlibrary @kindex info share @@ -8984,9 +9009,12 @@ required by your program for a core file or after typing @code{run}. If loaded. @end table -On HP-UX systems, @value{GDBN} detects the loading of a shared library -and automatically reads in symbols from the newly loaded library, up to -a threshold that is initially set but that you can modify if you wish. +On some systems, such as HP-UX systems, @value{GDBN} supports +autoloading shared library symbols until a limiting threshold size is +reached. This provides the benefit of allowing autoloading to remain on +by default, but avoids autoloading excessively large shared libraries, +up to a threshold that is initially set, but which you can modify if you +wish. Beyond that threshold, symbols from shared libraries must be explicitly loaded. To load these symbols, use the command @code{sharedlibrary @@ -8996,18 +9024,18 @@ automatically by @value{GDBN} and need not be specified. To display or set the threshold, use the commands: @table @code -@kindex set auto-solib-add -@item set auto-solib-add @var{threshold} -Set the autoloading size threshold, in megabytes. If @var{threshold} is -nonzero, symbols from all shared object libraries will be loaded -automatically when the inferior begins execution or when the dynamic -linker informs @value{GDBN} that a new library has been loaded, until -the symbol table of the program and libraries exceeds this threshold. +@kindex set auto-solib-limit +@item set auto-solib-limit @var{threshold} +Set the autoloading size threshold, in an integral number of megabytes. +If @var{threshold} is nonzero and shared library autoloading is enabled, +symbols from all shared object libraries will be loaded until the total +size of the loaded shared library symbols exceeds this threshold. Otherwise, symbols must be loaded manually, using the -@code{sharedlibrary} command. The default threshold is 100 megabytes. +@code{sharedlibrary} command. The default threshold is 100 (i.e. 100 +Mb). -@kindex show auto-solib-add -@item show auto-solib-add +@kindex show auto-solib-limit +@item show auto-solib-limit Display the current autoloading size threshold, in megabytes. @end table diff --git a/gdb/irix5-nat.c b/gdb/irix5-nat.c index 3c32840..2781bf3 100644 --- a/gdb/irix5-nat.c +++ b/gdb/irix5-nat.c @@ -1287,13 +1287,13 @@ _initialize_solib (void) "Status of loaded shared object libraries."); add_show_from_set - (add_set_cmd ("auto-solib-add", class_support, var_zinteger, + (add_set_cmd ("auto-solib-add", class_support, var_boolean, (char *) &auto_solib_add, "Set autoloading of shared library symbols.\n\ -If nonzero, symbols from all shared object libraries will be loaded\n\ -automatically when the inferior begins execution or when the dynamic linker\n\ -informs gdb that a new library has been loaded. Otherwise, symbols\n\ -must be loaded manually, using `sharedlibrary'.", +If \"on\", symbols from all shared object libraries will be loaded\n\ +automatically when the inferior begins execution, when the dynamic linker\n\ +informs gdb that a new library has been loaded, or when attaching to the\n\ +inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'.", &setlist), &showlist); } diff --git a/gdb/osfsolib.c b/gdb/osfsolib.c index 734cbc2..ac5c4de 100644 --- a/gdb/osfsolib.c +++ b/gdb/osfsolib.c @@ -924,13 +924,13 @@ _initialize_solib (void) "Status of loaded shared object libraries."); add_show_from_set - (add_set_cmd ("auto-solib-add", class_support, var_zinteger, + (add_set_cmd ("auto-solib-add", class_support, var_boolean, (char *) &auto_solib_add, "Set autoloading of shared library symbols.\n\ -If nonzero, symbols from all shared object libraries will be loaded\n\ -automatically when the inferior begins execution or when the dynamic linker\n\ -informs gdb that a new library has been loaded. Otherwise, symbols\n\ -must be loaded manually, using `sharedlibrary'.", +If \"on\", symbols from all shared object libraries will be loaded\n\ +automatically when the inferior begins execution, when the dynamic linker\n\ +informs gdb that a new library has been loaded, or when attaching to the\n\ +inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'.", &setlist), &showlist); } diff --git a/gdb/pa64solib.c b/gdb/pa64solib.c index cfafa28..e39d9e3 100644 --- a/gdb/pa64solib.c +++ b/gdb/pa64solib.c @@ -89,20 +89,20 @@ static struct so_list *so_list_head; shared objects on the so_list_head list. (When we say size, here we mean of the information before it is brought into memory and potentially expanded by GDB.) When adding a new shlib, this value - is compared against the threshold size, held by auto_solib_add - (in megabytes). If adding symbols for the new shlib would cause - the total size to exceed the threshold, then the new shlib's symbols - are not loaded. */ + is compared against a threshold size, held by auto_solib_limit (in + megabytes). If adding symbols for the new shlib would cause the + total size to exceed the threshold, then the new shlib's symbols + are not loaded. */ static LONGEST pa64_solib_total_st_size; /* When the threshold is reached for any shlib, we refuse to add symbols for subsequent shlibs, even if those shlibs' symbols would - be small enough to fit under the threshold. (Although this may + be small enough to fit under the threshold. Although this may result in one, early large shlib preventing the loading of later, - smalller shlibs' symbols, it allows us to issue one informational + smaller shlibs' symbols, it allows us to issue one informational message. The alternative, to issue a message for each shlib whose symbols aren't loaded, could be a big annoyance where the threshold - is exceeded due to a very large number of shlibs.) */ + is exceeded due to a very large number of shlibs. */ static int pa64_solib_st_size_threshold_exceeded; /* When adding fields, be sure to clear them in _initialize_pa64_solib. */ @@ -368,7 +368,7 @@ pa64_solib_load_symbols (struct so_list *so, char *name, int from_tty, /* Add symbols from shared libraries into the symtab list, unless the - size threshold (specified by auto_solib_add, in megabytes) would + size threshold specified by auto_solib_limit (in megabytes) would be exceeded. */ void @@ -886,28 +886,37 @@ _initialize_pa64_solib (void) "Load shared object library symbols for files matching REGEXP."); add_info ("sharedlibrary", pa64_sharedlibrary_info_command, "Status of loaded shared object libraries."); + add_show_from_set - (add_set_cmd ("auto-solib-add", class_support, var_zinteger, + (add_set_cmd ("auto-solib-add", class_support, var_boolean, (char *) &auto_solib_add, - "Set autoloading size threshold (in megabytes) of shared library symbols.\n\ -If nonzero, symbols from all shared object libraries will be loaded\n\ -automatically when the inferior begins execution or when the dynamic linker\n\ -informs gdb that a new library has been loaded, until the symbol table\n\ -of the program and libraries exceeds this threshold.\n\ -Otherwise, symbols must be loaded manually, using `sharedlibrary'.", + "Set autoloading of shared library symbols.\n\ +If \"on\", symbols from all shared object libraries will be loaded\n\ +automatically when the inferior begins execution, when the dynamic linker\n\ +informs gdb that a new library has been loaded, or when attaching to the\n\ +inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'.", + &setlist), + &showlist); + + add_show_from_set + (add_set_cmd ("auto-solib-limit", class_support, var_zinteger, + (char *) &auto_solib_limit, + "Set threshold (in Mb) for autoloading shared library symbols.\n\ +When shared library autoloading is enabled, new libraries will be loaded\n\ +only until the total size of shared library symbols exceeds this\n\ +threshold in megabytes. Is ignored when using `sharedlibrary'.", &setlist), &showlist); - /* ??rehrauer: On HP-UX, the kernel parameter MAXDSIZ limits how much - data space a process can use. We ought to be reading MAXDSIZ and - setting auto_solib_add to some large fraction of that value. If - not that, we maybe ought to be setting it smaller than the default - for MAXDSIZ (that being 64Mb, I believe). However, [1] this threshold - is only crudely approximated rather than actually measured, and [2] - 50 Mbytes is too small for debugging gdb itself. Thus, the arbitrary - 100 figure. - */ - auto_solib_add = 100; /* Megabytes */ + /* ??rehrauer: On HP-UX, the kernel parameter MAXDSIZ limits how + much data space a process can use. We ought to be reading + MAXDSIZ and setting auto_solib_limit to some large fraction of + that value. If not that, we maybe ought to be setting it smaller + than the default for MAXDSIZ (that being 64Mb, I believe). + However, [1] this threshold is only crudely approximated rather + than actually measured, and [2] 50 Mbytes is too small for + debugging gdb itself. Thus, the arbitrary 100 figure. */ + auto_solib_limit = 100; /* Megabytes */ pa64_solib_restart (); } @@ -1157,8 +1166,9 @@ add_to_solist (boolean from_tty, char *dll_path, st_size = pa64_solib_sizeof_symbol_table (dll_path); pa64_solib_st_size_threshhold_exceeded = !from_tty + && auto_solib_add && ( (st_size + pa64_solib_total_st_size) - > (auto_solib_add * (LONGEST)1000000)); + > (auto_solib_limit * (LONGEST)1000000)); if (pa64_solib_st_size_threshhold_exceeded) { pa64_solib_add_solib_objfile (new_so, dll_path, from_tty, 1); diff --git a/gdb/solib.c b/gdb/solib.c index c43858e..a2f4c81 100644 --- a/gdb/solib.c +++ b/gdb/solib.c @@ -841,13 +841,13 @@ _initialize_solib (void) "Unload all shared object library symbols."); add_show_from_set - (add_set_cmd ("auto-solib-add", class_support, var_zinteger, + (add_set_cmd ("auto-solib-add", class_support, var_boolean, (char *) &auto_solib_add, "Set autoloading of shared library symbols.\n\ -If nonzero, symbols from all shared object libraries will be loaded\n\ -automatically when the inferior begins execution or when the dynamic linker\n\ -informs gdb that a new library has been loaded. Otherwise, symbols\n\ -must be loaded manually, using `sharedlibrary'.", +If \"on\", symbols from all shared object libraries will be loaded\n\ +automatically when the inferior begins execution, when the dynamic linker\n\ +informs gdb that a new library has been loaded, or when attaching to the\n\ +inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'.", &setlist), &showlist); diff --git a/gdb/somsolib.c b/gdb/somsolib.c index 77c54e1..f9807ab 100644 --- a/gdb/somsolib.c +++ b/gdb/somsolib.c @@ -161,11 +161,10 @@ static struct so_list *so_list_head; shared objects on the so_list_head list. (When we say size, here we mean of the information before it is brought into memory and potentially expanded by GDB.) When adding a new shlib, this value - is compared against the threshold size, held by auto_solib_add + is compared against the threshold size, held by auto_solib_limit (in megabytes). If adding symbols for the new shlib would cause - the total size to exceed the threshold, then the new shlib's symbols - are not loaded. - */ + the total size to exceed the threshold, then the new shlib's + symbols are not loaded. */ static LONGEST som_solib_total_st_size; /* When the threshold is reached for any shlib, we refuse to add @@ -403,7 +402,7 @@ som_solib_load_symbols (struct so_list *so, char *name, int from_tty, /* Add symbols from shared libraries into the symtab list, unless the - size threshold (specified by auto_solib_add, in megabytes) would + size threshold specified by auto_solib_limit (in megabytes) would be exceeded. */ void @@ -778,12 +777,13 @@ som_solib_add (char *arg_string, int from_tty, struct target_ops *target) st_size = som_solib_sizeof_symbol_table (name); som_solib_st_size_threshold_exceeded = !from_tty && - ((st_size + som_solib_total_st_size) > (auto_solib_add * (LONGEST) 1000000)); + auto_solib_add && + ((st_size + som_solib_total_st_size) > (auto_solib_limit * (LONGEST) 1000000)); if (som_solib_st_size_threshold_exceeded) { if (!threshold_warning_given) - warning ("Symbols for some libraries have not been loaded, because\ndoing so would exceed the size threshold specified by auto-solib-add.\nTo manually load symbols, use the 'sharedlibrary' command.\nTo raise the threshold, set auto-solib-add to a larger value and rerun\nthe program.\n"); + warning ("Symbols for some libraries have not been loaded, because\ndoing so would exceed the size threshold specified by auto-solib-limit.\nTo manually load symbols, use the 'sharedlibrary' command.\nTo raise the threshold, set auto-solib-limit to a larger value and rerun\nthe program.\n"); threshold_warning_given = 1; /* We'll still make note of this shlib, even if we don't @@ -1571,28 +1571,37 @@ _initialize_som_solib (void) "Load shared object library symbols for files matching REGEXP."); add_info ("sharedlibrary", som_sharedlibrary_info_command, "Status of loaded shared object libraries."); + add_show_from_set - (add_set_cmd ("auto-solib-add", class_support, var_zinteger, + (add_set_cmd ("auto-solib-add", class_support, var_boolean, (char *) &auto_solib_add, - "Set autoloading size threshold (in megabytes) of shared library symbols.\n\ -If nonzero, symbols from all shared object libraries will be loaded\n\ -automatically when the inferior begins execution or when the dynamic linker\n\ -informs gdb that a new library has been loaded, until the symbol table\n\ -of the program and libraries exceeds this threshold.\n\ -Otherwise, symbols must be loaded manually, using `sharedlibrary'.", + "Set autoloading of shared library symbols.\n\ +If \"on\", symbols from all shared object libraries will be loaded\n\ +automatically when the inferior begins execution, when the dynamic linker\n\ +informs gdb that a new library has been loaded, or when attaching to the\n\ +inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'.", &setlist), &showlist); - /* ??rehrauer: On HP-UX, the kernel parameter MAXDSIZ limits how much - data space a process can use. We ought to be reading MAXDSIZ and - setting auto_solib_add to some large fraction of that value. If - not that, we maybe ought to be setting it smaller than the default - for MAXDSIZ (that being 64Mb, I believe). However, [1] this threshold - is only crudely approximated rather than actually measured, and [2] - 50 Mbytes is too small for debugging gdb itself. Thus, the arbitrary - 100 figure. - */ - auto_solib_add = 100; /* Megabytes */ + add_show_from_set + (add_set_cmd ("auto-solib-limit", class_support, var_zinteger, + (char *) &auto_solib_limit, + "Set threshold (in Mb) for autoloading shared library symbols.\n\ +When shared library autoloading is enabled, new libraries will be loaded\n\ +only until the total size of shared library symbols exceeds this\n\ +threshold in megabytes. Is ignored when using `sharedlibrary'.", + &setlist), + &showlist); + + /* ??rehrauer: On HP-UX, the kernel parameter MAXDSIZ limits how + much data space a process can use. We ought to be reading + MAXDSIZ and setting auto_solib_limit to some large fraction of + that value. If not that, we maybe ought to be setting it smaller + than the default for MAXDSIZ (that being 64Mb, I believe). + However, [1] this threshold is only crudely approximated rather + than actually measured, and [2] 50 Mbytes is too small for + debugging gdb itself. Thus, the arbitrary 100 figure. */ + auto_solib_limit = 100; /* Megabytes */ som_solib_restart (); } diff --git a/gdb/symfile.c b/gdb/symfile.c index 7f3fdc6..010726d 100644 --- a/gdb/symfile.c +++ b/gdb/symfile.c @@ -177,27 +177,27 @@ int symbol_reloading = SYMBOL_RELOADING_DEFAULT; int symbol_reloading = 0; #endif -/* If non-zero, then on HP-UX (i.e., platforms that use somsolib.c), - this variable is interpreted as a threshhold. If adding a new - library's symbol table to those already known to the debugger would - exceed this threshhold, then the shlib's symbols are not added. - - If non-zero on other platforms, shared library symbols will be added - automatically when the inferior is created, new libraries are loaded, - or when attaching to the inferior. This is almost always what users - will want to have happen; but for very large programs, the startup - time will be excessive, and so if this is a problem, the user can - clear this flag and then add the shared library symbols as needed. - Note that there is a potential for confusion, since if the shared +/* If non-zero, shared library symbols will be added automatically + when the inferior is created, new libraries are loaded, or when + attaching to the inferior. This is almost always what users will + want to have happen; but for very large programs, the startup time + will be excessive, and so if this is a problem, the user can clear + this flag and then add the shared library symbols as needed. Note + that there is a potential for confusion, since if the shared library symbols are not loaded, commands like "info fun" will *not* - report all the functions that are actually present. - - Note that HP-UX interprets this variable to mean, "threshhold size - in megabytes, where zero means never add". Other platforms interpret - this variable to mean, "always add if non-zero, never add if zero." - */ + report all the functions that are actually present. */ int auto_solib_add = 1; + +/* For systems that support it, a threshold size in megabytes. If + automatically adding a new library's symbol table to those already + known to the debugger would cause the total shared library symbol + size to exceed this threshhold, then the shlib's symbols are not + added. The threshold is ignored if the user explicitly asks for a + shlib to be added, such as when using the "sharedlibrary" + command. */ + +int auto_solib_limit; /* Since this function is called from within qsort, in an ANSI environment diff --git a/gdb/symfile.h b/gdb/symfile.h index 36447d7..a6bf3f6 100644 --- a/gdb/symfile.h +++ b/gdb/symfile.h @@ -218,18 +218,27 @@ extern char *obconcat (struct obstack *obstackp, const char *, const char *, /* Variables */ -/* whether to auto load solibs at startup time: 0/1. +/* If non-zero, shared library symbols will be added automatically + when the inferior is created, new libraries are loaded, or when + attaching to the inferior. This is almost always what users will + want to have happen; but for very large programs, the startup time + will be excessive, and so if this is a problem, the user can clear + this flag and then add the shared library symbols as needed. Note + that there is a potential for confusion, since if the shared + library symbols are not loaded, commands like "info fun" will *not* + report all the functions that are actually present. */ - On all platforms, 0 means "don't auto load". - - On HP-UX, > 0 means a threshhold, in megabytes, of symbol table which will - be auto loaded. When the cumulative size of solib symbol table exceeds - this threshhold, solibs' symbol tables will not be loaded. +extern int auto_solib_add; - On other platforms, > 0 means, "always auto load". - */ +/* For systems that support it, a threshold size in megabytes. If + automatically adding a new library's symbol table to those already + known to the debugger would cause the total shared library symbol + size to exceed this threshhold, then the shlib's symbols are not + added. The threshold is ignored if the user explicitly asks for a + shlib to be added, such as when using the "sharedlibrary" + command. */ -extern int auto_solib_add; +extern int auto_solib_limit; /* From symfile.c */ diff --git a/gdb/xcoffsolib.c b/gdb/xcoffsolib.c index d6f15e5..00e51f3 100644 --- a/gdb/xcoffsolib.c +++ b/gdb/xcoffsolib.c @@ -184,13 +184,13 @@ _initialize_solib (void) "Status of loaded shared object libraries"); add_show_from_set - (add_set_cmd ("auto-solib-add", class_support, var_zinteger, + (add_set_cmd ("auto-solib-add", class_support, var_boolean, (char *) &auto_solib_add, "Set autoloading of shared library symbols.\n\ -If nonzero, symbols from all shared object libraries will be loaded\n\ -automatically when the inferior begins execution or when the dynamic linker\n\ -informs gdb that a new library has been loaded. Otherwise, symbols\n\ -must be loaded manually, using `sharedlibrary'.", +If \"on\", symbols from all shared object libraries will be loaded\n\ +automatically when the inferior begins execution, when the dynamic linker\n\ +informs gdb that a new library has been loaded, or when attaching to the\n\ +inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'.", &setlist), &showlist); } -- cgit v1.1