1 /* GDB routines for supporting auto-loaded scripts.
3 Copyright (C) 2012 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "auto-load.h"
22 #include "progspace.h"
23 #include "python/python.h"
24 #include "gdb_regex.h"
26 #include "filenames.h"
30 #include "exceptions.h"
31 #include "cli/cli-script.h"
33 #include "cli/cli-decode.h"
34 #include "cli/cli-setshow.h"
36 #include "readline/tilde.h"
37 #include "completer.h"
39 /* The suffix of per-objfile scripts to auto-load as non-Python command files.
40 E.g. When the program loads libfoo.so, look for libfoo-gdb.gdb. */
41 #define GDB_AUTO_FILE_NAME "-gdb.gdb"
43 static void source_gdb_script_for_objfile (struct objfile *objfile, FILE *file,
44 const char *filename);
46 /* Value of the 'set debug auto-load' configuration variable. */
47 static int debug_auto_load = 0;
49 /* "show" command for the debug_auto_load configuration variable. */
52 show_debug_auto_load (struct ui_file *file, int from_tty,
53 struct cmd_list_element *c, const char *value)
55 fprintf_filtered (file, _("Debugging output for files "
56 "of 'set auto-load ...' is %s.\n"),
60 /* User-settable option to enable/disable auto-loading of GDB_AUTO_FILE_NAME
62 set auto-load gdb-scripts on|off
63 This is true if we should auto-load associated scripts when an objfile
64 is opened, false otherwise. */
65 static int auto_load_gdb_scripts = 1;
67 /* "show" command for the auto_load_gdb_scripts configuration variable. */
70 show_auto_load_gdb_scripts (struct ui_file *file, int from_tty,
71 struct cmd_list_element *c, const char *value)
73 fprintf_filtered (file, _("Auto-loading of canned sequences of commands "
78 /* Internal-use flag to enable/disable auto-loading.
79 This is true if we should auto-load python code when an objfile is opened,
82 Both auto_load_scripts && global_auto_load must be true to enable
85 This flag exists to facilitate deferring auto-loading during start-up
86 until after ./.gdbinit has been read; it may augment the search directories
87 used to find the scripts. */
88 int global_auto_load = 1;
90 /* Auto-load .gdbinit file from the current directory? */
91 int auto_load_local_gdbinit = 1;
93 /* Absolute pathname to the current directory .gdbinit, if it exists. */
94 char *auto_load_local_gdbinit_pathname = NULL;
96 /* Boolean value if AUTO_LOAD_LOCAL_GDBINIT_PATHNAME has been loaded. */
97 int auto_load_local_gdbinit_loaded = 0;
99 /* "show" command for the auto_load_local_gdbinit configuration variable. */
102 show_auto_load_local_gdbinit (struct ui_file *file, int from_tty,
103 struct cmd_list_element *c, const char *value)
105 fprintf_filtered (file, _("Auto-loading of .gdbinit script from current "
106 "directory is %s.\n"),
110 /* Directory list safe to hold auto-loaded files. It is not checked for
111 absolute paths but they are strongly recommended. It is initialized by
112 _initialize_auto_load. */
113 static char *auto_load_safe_path;
115 /* Vector of directory elements of AUTO_LOAD_SAFE_PATH with each one normalized
116 by tilde_expand and possibly each entries has added its gdb_realpath
118 static VEC (char_ptr) *auto_load_safe_path_vec;
120 /* Update auto_load_safe_path_vec from current AUTO_LOAD_SAFE_PATH. */
123 auto_load_safe_path_vec_update (void)
125 VEC (char_ptr) *dir_vec = NULL;
130 fprintf_unfiltered (gdb_stdlog,
131 _("auto-load: Updating directories of \"%s\".\n"),
132 auto_load_safe_path);
134 free_char_ptr_vec (auto_load_safe_path_vec);
136 auto_load_safe_path_vec = dirnames_to_char_ptr_vec (auto_load_safe_path);
137 len = VEC_length (char_ptr, auto_load_safe_path_vec);
139 /* Apply tilde_expand and gdb_realpath to each AUTO_LOAD_SAFE_PATH_VEC
141 for (ix = 0; ix < len; ix++)
143 char *dir = VEC_index (char_ptr, auto_load_safe_path_vec, ix);
144 char *expanded = tilde_expand (dir);
145 char *real_path = gdb_realpath (expanded);
147 /* Ensure the current entry is at least tilde_expand-ed. */
148 VEC_replace (char_ptr, auto_load_safe_path_vec, ix, expanded);
152 if (strcmp (expanded, dir) == 0)
153 fprintf_unfiltered (gdb_stdlog,
154 _("auto-load: Using directory \"%s\".\n"),
157 fprintf_unfiltered (gdb_stdlog,
158 _("auto-load: Resolved directory \"%s\" "
164 /* If gdb_realpath returns a different content, append it. */
165 if (strcmp (real_path, expanded) == 0)
169 VEC_safe_push (char_ptr, auto_load_safe_path_vec, real_path);
172 fprintf_unfiltered (gdb_stdlog,
173 _("auto-load: And canonicalized as \"%s\".\n"),
179 /* "set" command for the auto_load_safe_path configuration variable. */
182 set_auto_load_safe_path (char *args, int from_tty, struct cmd_list_element *c)
184 auto_load_safe_path_vec_update ();
187 /* "show" command for the auto_load_safe_path configuration variable. */
190 show_auto_load_safe_path (struct ui_file *file, int from_tty,
191 struct cmd_list_element *c, const char *value)
194 fprintf_filtered (file, _("Auto-load files are safe to load from any "
197 fprintf_filtered (file, _("List of directories from which it is safe to "
198 "auto-load files is %s.\n"),
202 /* "add-auto-load-safe-path" command for the auto_load_safe_path configuration
206 add_auto_load_safe_path (char *args, int from_tty)
210 if (args == NULL || *args == 0)
212 Adding empty directory element disables the auto-load safe-path security. \
213 Use 'set auto-load safe-path' instead if you mean that."));
215 s = xstrprintf ("%s%c%s", auto_load_safe_path, DIRNAME_SEPARATOR, args);
216 xfree (auto_load_safe_path);
217 auto_load_safe_path = s;
219 auto_load_safe_path_vec_update ();
222 /* Return 1 if FILENAME is equal to DIR or if FILENAME belongs to the
223 subdirectory DIR. Return 0 otherwise. gdb_realpath normalization is never
226 static ATTRIBUTE_PURE int
227 filename_is_in_dir (const char *filename, const char *dir)
229 size_t dir_len = strlen (dir);
231 while (dir_len && IS_DIR_SEPARATOR (dir[dir_len - 1]))
234 return (filename_ncmp (dir, filename, dir_len) == 0
235 && (IS_DIR_SEPARATOR (filename[dir_len])
236 || filename[dir_len] == '\0'));
239 /* Return 1 if FILENAME belongs to one of directory components of
240 AUTO_LOAD_SAFE_PATH_VEC. Return 0 otherwise.
241 auto_load_safe_path_vec_update is never called.
242 *FILENAME_REALP may be updated by gdb_realpath of FILENAME - it has to be
243 freed by the caller. */
246 filename_is_in_auto_load_safe_path_vec (const char *filename,
247 char **filename_realp)
252 for (ix = 0; VEC_iterate (char_ptr, auto_load_safe_path_vec, ix, dir); ++ix)
253 if (*filename_realp == NULL && filename_is_in_dir (filename, dir))
258 if (*filename_realp == NULL)
260 *filename_realp = gdb_realpath (filename);
261 if (debug_auto_load && strcmp (*filename_realp, filename) != 0)
262 fprintf_unfiltered (gdb_stdlog,
263 _("auto-load: Resolved "
264 "file \"%s\" as \"%s\".\n"),
265 filename, *filename_realp);
268 if (strcmp (*filename_realp, filename) != 0)
269 for (ix = 0; VEC_iterate (char_ptr, auto_load_safe_path_vec, ix, dir);
271 if (filename_is_in_dir (*filename_realp, dir))
278 fprintf_unfiltered (gdb_stdlog, _("auto-load: File \"%s\" matches "
279 "directory \"%s\".\n"),
287 /* Return 1 if FILENAME is located in one of the directories of
288 AUTO_LOAD_SAFE_PATH. Otherwise call warning and return 0. FILENAME does
289 not have to be an absolute path.
291 Existence of FILENAME is not checked. Function will still give a warning
292 even if the caller would quietly skip non-existing file in unsafe
296 file_is_auto_load_safe (const char *filename, const char *debug_fmt, ...)
298 char *filename_real = NULL;
299 struct cleanup *back_to;
305 va_start (debug_args, debug_fmt);
306 vfprintf_unfiltered (gdb_stdlog, debug_fmt, debug_args);
310 back_to = make_cleanup (free_current_contents, &filename_real);
312 if (filename_is_in_auto_load_safe_path_vec (filename, &filename_real))
314 do_cleanups (back_to);
318 auto_load_safe_path_vec_update ();
319 if (filename_is_in_auto_load_safe_path_vec (filename, &filename_real))
321 do_cleanups (back_to);
325 warning (_("File \"%s\" auto-loading has been declined by your "
326 "`auto-load safe-path' set to \"%s\"."),
327 filename_real, auto_load_safe_path);
329 do_cleanups (back_to);
333 /* Definition of script language for GDB canned sequences of commands. */
335 static const struct script_language script_language_gdb
336 = { GDB_AUTO_FILE_NAME, source_gdb_script_for_objfile };
339 source_gdb_script_for_objfile (struct objfile *objfile, FILE *file,
340 const char *filename)
343 struct auto_load_pspace_info *pspace_info;
344 volatile struct gdb_exception e;
346 is_safe = file_is_auto_load_safe (filename, _("auto-load: Loading canned "
347 "sequences of commands script "
348 "\"%s\" for objfile \"%s\".\n"),
349 filename, objfile->name);
351 /* Add this script to the hash table too so "info auto-load gdb-scripts"
353 pspace_info = get_auto_load_pspace_data_for_loading (current_program_space);
354 maybe_add_script (pspace_info, is_safe, filename, filename,
355 &script_language_gdb);
360 TRY_CATCH (e, RETURN_MASK_ALL)
362 script_from_file (file, filename);
364 exception_print (gdb_stderr, e);
367 /* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
368 the same script. There's no point in loading the script multiple times,
369 and there can be a lot of objfiles and scripts, so we keep track of scripts
372 struct auto_load_pspace_info
374 /* For each program space we keep track of loaded scripts. */
375 struct htab *loaded_scripts;
377 /* Non-zero if we've issued the warning about an auto-load script not being
378 found. We only want to issue this warning once. */
379 int script_not_found_warning_printed;
382 /* Objects of this type are stored in the loaded script hash table. */
386 /* Name as provided by the objfile. */
389 /* Full path name or NULL if script wasn't found (or was otherwise
391 const char *full_path;
393 /* Non-zero if this script has been loaded. */
396 const struct script_language *language;
399 /* Per-program-space data key. */
400 static const struct program_space_data *auto_load_pspace_data;
403 auto_load_pspace_data_cleanup (struct program_space *pspace, void *arg)
405 struct auto_load_pspace_info *info;
407 info = program_space_data (pspace, auto_load_pspace_data);
410 if (info->loaded_scripts)
411 htab_delete (info->loaded_scripts);
416 /* Get the current autoload data. If none is found yet, add it now. This
417 function always returns a valid object. */
419 static struct auto_load_pspace_info *
420 get_auto_load_pspace_data (struct program_space *pspace)
422 struct auto_load_pspace_info *info;
424 info = program_space_data (pspace, auto_load_pspace_data);
427 info = XZALLOC (struct auto_load_pspace_info);
428 set_program_space_data (pspace, auto_load_pspace_data, info);
434 /* Hash function for the loaded script hash. */
437 hash_loaded_script_entry (const void *data)
439 const struct loaded_script *e = data;
441 return htab_hash_string (e->name) ^ htab_hash_pointer (e->language);
444 /* Equality function for the loaded script hash. */
447 eq_loaded_script_entry (const void *a, const void *b)
449 const struct loaded_script *ea = a;
450 const struct loaded_script *eb = b;
452 return strcmp (ea->name, eb->name) == 0 && ea->language == eb->language;
455 /* Initialize the table to track loaded scripts.
456 Each entry is hashed by the full path name. */
459 init_loaded_scripts_info (struct auto_load_pspace_info *pspace_info)
461 /* Choose 31 as the starting size of the hash table, somewhat arbitrarily.
462 Space for each entry is obtained with one malloc so we can free them
465 pspace_info->loaded_scripts = htab_create (31,
466 hash_loaded_script_entry,
467 eq_loaded_script_entry,
470 pspace_info->script_not_found_warning_printed = FALSE;
473 /* Wrapper on get_auto_load_pspace_data to also allocate the hash table
474 for loading scripts. */
476 struct auto_load_pspace_info *
477 get_auto_load_pspace_data_for_loading (struct program_space *pspace)
479 struct auto_load_pspace_info *info;
481 info = get_auto_load_pspace_data (pspace);
482 if (info->loaded_scripts == NULL)
483 init_loaded_scripts_info (info);
488 /* Add script NAME in LANGUAGE to hash table of PSPACE_INFO. LOADED 1 if the
489 script has been (is going to) be loaded, 0 otherwise (such as if it has not
490 been found). FULL_PATH is NULL if the script wasn't found. The result is
491 true if the script was already in the hash table. */
494 maybe_add_script (struct auto_load_pspace_info *pspace_info, int loaded,
495 const char *name, const char *full_path,
496 const struct script_language *language)
498 struct htab *htab = pspace_info->loaded_scripts;
499 struct loaded_script **slot, entry;
503 entry.language = language;
504 slot = (struct loaded_script **) htab_find_slot (htab, &entry, INSERT);
505 in_hash_table = *slot != NULL;
507 /* If this script is not in the hash table, add it. */
513 /* Allocate all space in one chunk so it's easier to free. */
514 *slot = xmalloc (sizeof (**slot)
516 + (full_path != NULL ? (strlen (full_path) + 1) : 0));
517 p = ((char*) *slot) + sizeof (**slot);
520 if (full_path != NULL)
523 strcpy (p, full_path);
524 (*slot)->full_path = p;
527 (*slot)->full_path = NULL;
528 (*slot)->loaded = loaded;
529 (*slot)->language = language;
532 return in_hash_table;
535 /* Clear the table of loaded section scripts. */
538 clear_section_scripts (void)
540 struct program_space *pspace = current_program_space;
541 struct auto_load_pspace_info *info;
543 info = program_space_data (pspace, auto_load_pspace_data);
544 if (info != NULL && info->loaded_scripts != NULL)
546 htab_delete (info->loaded_scripts);
547 info->loaded_scripts = NULL;
548 info->script_not_found_warning_printed = FALSE;
552 /* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
556 auto_load_objfile_script (struct objfile *objfile,
557 const struct script_language *language)
560 char *filename, *debugfile;
563 struct cleanup *cleanups;
565 realname = gdb_realpath (objfile->name);
566 len = strlen (realname);
567 filename = xmalloc (len + strlen (language->suffix) + 1);
568 memcpy (filename, realname, len);
569 strcpy (filename + len, language->suffix);
571 cleanups = make_cleanup (xfree, filename);
572 make_cleanup (xfree, realname);
574 input = fopen (filename, "r");
575 debugfile = filename;
577 if (!input && debug_file_directory)
579 /* Also try the same file in the separate debug info directory. */
580 debugfile = xmalloc (strlen (filename)
581 + strlen (debug_file_directory) + 1);
582 strcpy (debugfile, debug_file_directory);
583 /* FILENAME is absolute, so we don't need a "/" here. */
584 strcat (debugfile, filename);
586 make_cleanup (xfree, debugfile);
587 input = fopen (debugfile, "r");
590 if (!input && gdb_datadir)
592 /* Also try the same file in a subdirectory of gdb's data
594 debugfile = xmalloc (strlen (gdb_datadir) + strlen (filename)
595 + strlen ("/auto-load") + 1);
596 strcpy (debugfile, gdb_datadir);
597 strcat (debugfile, "/auto-load");
598 /* FILENAME is absolute, so we don't need a "/" here. */
599 strcat (debugfile, filename);
601 make_cleanup (xfree, debugfile);
602 input = fopen (debugfile, "r");
607 make_cleanup_fclose (input);
609 /* To preserve existing behaviour we don't check for whether the
610 script was already in the table, and always load it.
611 It's highly unlikely that we'd ever load it twice,
612 and these scripts are required to be idempotent under multiple
614 language->source_script_for_objfile (objfile, input, debugfile);
617 do_cleanups (cleanups);
620 /* Load any auto-loaded scripts for OBJFILE. */
623 load_auto_scripts_for_objfile (struct objfile *objfile)
625 if (!global_auto_load)
628 if (auto_load_gdb_scripts)
629 auto_load_objfile_script (objfile, &script_language_gdb);
631 gdbpy_load_auto_scripts_for_objfile (objfile);
634 /* This is a new_objfile observer callback to auto-load scripts.
636 Two flavors of auto-loaded scripts are supported.
637 1) based on the path to the objfile
638 2) from .debug_gdb_scripts section */
641 auto_load_new_objfile (struct objfile *objfile)
645 /* OBJFILE is NULL when loading a new "main" symbol-file. */
646 clear_section_scripts ();
650 load_auto_scripts_for_objfile (objfile);
653 /* Collect scripts to be printed in a vec. */
655 typedef struct loaded_script *loaded_script_ptr;
656 DEF_VEC_P (loaded_script_ptr);
658 struct collect_matching_scripts_data
660 VEC (loaded_script_ptr) **scripts_p;
662 const struct script_language *language;
665 /* Traversal function for htab_traverse.
666 Collect the entry if it matches the regexp. */
669 collect_matching_scripts (void **slot, void *info)
671 struct loaded_script *script = *slot;
672 struct collect_matching_scripts_data *data = info;
674 if (script->language == data->language && re_exec (script->name))
675 VEC_safe_push (loaded_script_ptr, *data->scripts_p, script);
683 print_script (struct loaded_script *script)
685 struct ui_out *uiout = current_uiout;
686 struct cleanup *chain;
688 chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
690 ui_out_field_string (uiout, "loaded", script->loaded ? "Yes" : "No");
691 ui_out_field_string (uiout, "script", script->name);
692 ui_out_text (uiout, "\n");
694 /* If the name isn't the full path, print it too. */
695 if (script->full_path != NULL
696 && strcmp (script->name, script->full_path) != 0)
698 ui_out_text (uiout, "\tfull name: ");
699 ui_out_field_string (uiout, "full_path", script->full_path);
700 ui_out_text (uiout, "\n");
706 /* Helper for info_auto_load_scripts to sort the scripts by name. */
709 sort_scripts_by_name (const void *ap, const void *bp)
711 const struct loaded_script *a = *(const struct loaded_script **) ap;
712 const struct loaded_script *b = *(const struct loaded_script **) bp;
714 return FILENAME_CMP (a->name, b->name);
717 /* Special internal GDB value of auto_load_info_scripts's PATTERN identify
718 the "info auto-load XXX" command has been executed through the general
719 "info auto-load" invocation. Extra newline will be printed if needed. */
720 char auto_load_info_scripts_pattern_nl[] = "";
722 /* Implementation for "info auto-load gdb-scripts"
723 (and "info auto-load python-scripts"). List scripts in LANGUAGE matching
724 PATTERN. FROM_TTY is the usual GDB boolean for user interactivity. */
727 auto_load_info_scripts (char *pattern, int from_tty,
728 const struct script_language *language)
730 struct ui_out *uiout = current_uiout;
731 struct auto_load_pspace_info *pspace_info;
732 struct cleanup *script_chain;
733 VEC (loaded_script_ptr) *scripts;
738 pspace_info = get_auto_load_pspace_data (current_program_space);
740 if (pattern && *pattern)
742 char *re_err = re_comp (pattern);
745 error (_("Invalid regexp: %s"), re_err);
752 /* We need to know the number of rows before we build the table.
753 Plus we want to sort the scripts by name.
754 So first traverse the hash table collecting the matching scripts. */
756 scripts = VEC_alloc (loaded_script_ptr, 10);
757 script_chain = make_cleanup (VEC_cleanup (loaded_script_ptr), &scripts);
759 if (pspace_info != NULL && pspace_info->loaded_scripts != NULL)
761 struct collect_matching_scripts_data data = { &scripts, language };
764 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
765 htab_traverse_noresize (pspace_info->loaded_scripts,
766 collect_matching_scripts, &data);
770 nr_scripts = VEC_length (loaded_script_ptr, scripts);
772 /* Table header shifted right by preceding "gdb-scripts: " would not match
774 if (nr_scripts > 0 && pattern == auto_load_info_scripts_pattern_nl)
775 ui_out_text (uiout, "\n");
777 make_cleanup_ui_out_table_begin_end (uiout, 2, nr_scripts,
778 "AutoLoadedScriptsTable");
780 ui_out_table_header (uiout, 7, ui_left, "loaded", "Loaded");
781 ui_out_table_header (uiout, 70, ui_left, "script", "Script");
782 ui_out_table_body (uiout);
787 loaded_script_ptr script;
789 qsort (VEC_address (loaded_script_ptr, scripts),
790 VEC_length (loaded_script_ptr, scripts),
791 sizeof (loaded_script_ptr), sort_scripts_by_name);
792 for (i = 0; VEC_iterate (loaded_script_ptr, scripts, i, script); ++i)
793 print_script (script);
796 do_cleanups (script_chain);
800 if (pattern && *pattern)
801 ui_out_message (uiout, 0, "No auto-load scripts matching %s.\n",
804 ui_out_message (uiout, 0, "No auto-load scripts.\n");
808 /* Wrapper for "info auto-load gdb-scripts". */
811 info_auto_load_gdb_scripts (char *pattern, int from_tty)
813 auto_load_info_scripts (pattern, from_tty, &script_language_gdb);
816 /* Implement 'info auto-load local-gdbinit'. */
819 info_auto_load_local_gdbinit (char *args, int from_tty)
821 if (auto_load_local_gdbinit_pathname == NULL)
822 printf_filtered (_("Local .gdbinit file was not found.\n"));
823 else if (auto_load_local_gdbinit_loaded)
824 printf_filtered (_("Local .gdbinit file \"%s\" has been loaded.\n"),
825 auto_load_local_gdbinit_pathname);
827 printf_filtered (_("Local .gdbinit file \"%s\" has not been loaded.\n"),
828 auto_load_local_gdbinit_pathname);
831 /* Return non-zero if SCRIPT_NOT_FOUND_WARNING_PRINTED of PSPACE_INFO was unset
832 before calling this function. Always set SCRIPT_NOT_FOUND_WARNING_PRINTED
836 script_not_found_warning_print (struct auto_load_pspace_info *pspace_info)
838 int retval = !pspace_info->script_not_found_warning_printed;
840 pspace_info->script_not_found_warning_printed = 1;
845 /* The only valid "set auto-load" argument is off|0|no|disable. */
848 set_auto_load_cmd (char *args, int from_tty)
850 struct cmd_list_element *list;
853 /* See parse_binary_operation in use by the sub-commands. */
855 length = args ? strlen (args) : 0;
857 while (length > 0 && (args[length - 1] == ' ' || args[length - 1] == '\t'))
860 if (length == 0 || (strncmp (args, "off", length) != 0
861 && strncmp (args, "0", length) != 0
862 && strncmp (args, "no", length) != 0
863 && strncmp (args, "disable", length) != 0))
864 error (_("Valid is only global 'set auto-load no'; "
865 "otherwise check the auto-load sub-commands."));
867 for (list = *auto_load_set_cmdlist_get (); list != NULL; list = list->next)
868 if (list->var_type == var_boolean)
870 gdb_assert (list->type == set_cmd);
871 do_setshow_command (args, from_tty, list);
875 /* Initialize "set auto-load " commands prefix and return it. */
877 struct cmd_list_element **
878 auto_load_set_cmdlist_get (void)
880 static struct cmd_list_element *retval;
883 add_prefix_cmd ("auto-load", class_maintenance, set_auto_load_cmd, _("\
884 Auto-loading specific settings.\n\
885 Configure various auto-load-specific variables such as\n\
886 automatic loading of Python scripts."),
887 &retval, "set auto-load ",
888 1/*allow-unknown*/, &setlist);
893 /* Command "show auto-load" displays summary of all the current
894 "show auto-load " settings. */
897 show_auto_load_cmd (char *args, int from_tty)
899 cmd_show_list (*auto_load_show_cmdlist_get (), from_tty, "");
902 /* Initialize "show auto-load " commands prefix and return it. */
904 struct cmd_list_element **
905 auto_load_show_cmdlist_get (void)
907 static struct cmd_list_element *retval;
910 add_prefix_cmd ("auto-load", class_maintenance, show_auto_load_cmd, _("\
911 Show auto-loading specific settings.\n\
912 Show configuration of various auto-load-specific variables such as\n\
913 automatic loading of Python scripts."),
914 &retval, "show auto-load ",
915 0/*allow-unknown*/, &showlist);
920 /* Command "info auto-load" displays whether the various auto-load files have
921 been loaded. This is reimplementation of cmd_show_list which inserts
922 newlines at proper places. */
925 info_auto_load_cmd (char *args, int from_tty)
927 struct cmd_list_element *list;
928 struct cleanup *infolist_chain;
929 struct ui_out *uiout = current_uiout;
931 infolist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "infolist");
933 for (list = *auto_load_info_cmdlist_get (); list != NULL; list = list->next)
935 struct cleanup *option_chain
936 = make_cleanup_ui_out_tuple_begin_end (uiout, "option");
938 gdb_assert (!list->prefixlist);
939 gdb_assert (list->type == not_set_cmd);
941 ui_out_field_string (uiout, "name", list->name);
942 ui_out_text (uiout, ": ");
943 cmd_func (list, auto_load_info_scripts_pattern_nl, from_tty);
945 /* Close the tuple. */
946 do_cleanups (option_chain);
949 /* Close the tuple. */
950 do_cleanups (infolist_chain);
953 /* Initialize "info auto-load " commands prefix and return it. */
955 struct cmd_list_element **
956 auto_load_info_cmdlist_get (void)
958 static struct cmd_list_element *retval;
961 add_prefix_cmd ("auto-load", class_info, info_auto_load_cmd, _("\
962 Print current status of auto-loaded files.\n\
963 Print whether various files like Python scripts or .gdbinit files have been\n\
964 found and/or loaded."),
965 &retval, "info auto-load ",
966 0/*allow-unknown*/, &infolist);
971 void _initialize_auto_load (void);
974 _initialize_auto_load (void)
976 struct cmd_list_element *cmd;
978 auto_load_pspace_data
979 = register_program_space_data_with_cleanup (auto_load_pspace_data_cleanup);
981 observer_attach_new_objfile (auto_load_new_objfile);
983 add_setshow_boolean_cmd ("gdb-scripts", class_support,
984 &auto_load_gdb_scripts, _("\
985 Enable or disable auto-loading of canned sequences of commands scripts."), _("\
986 Show whether auto-loading of canned sequences of commands scripts is enabled."),
988 If enabled, canned sequences of commands are loaded when the debugger reads\n\
989 an executable or shared library.\n\
990 This options has security implications for untrusted inferiors."),
991 NULL, show_auto_load_gdb_scripts,
992 auto_load_set_cmdlist_get (),
993 auto_load_show_cmdlist_get ());
995 add_cmd ("gdb-scripts", class_info, info_auto_load_gdb_scripts,
996 _("Print the list of automatically loaded sequences of commands.\n\
997 Usage: info auto-load gdb-scripts [REGEXP]"),
998 auto_load_info_cmdlist_get ());
1000 add_setshow_boolean_cmd ("local-gdbinit", class_support,
1001 &auto_load_local_gdbinit, _("\
1002 Enable or disable auto-loading of .gdbinit script in current directory."), _("\
1003 Show whether auto-loading .gdbinit script in current directory is enabled."),
1005 If enabled, canned sequences of commands are loaded when debugger starts\n\
1006 from .gdbinit file in current directory. Such files are deprecated,\n\
1007 use a script associated with inferior executable file instead.\n\
1008 This options has security implications for untrusted inferiors."),
1009 NULL, show_auto_load_local_gdbinit,
1010 auto_load_set_cmdlist_get (),
1011 auto_load_show_cmdlist_get ());
1013 add_cmd ("local-gdbinit", class_info, info_auto_load_local_gdbinit,
1014 _("Print whether current directory .gdbinit file has been loaded.\n\
1015 Usage: info auto-load local-gdbinit"),
1016 auto_load_info_cmdlist_get ());
1018 auto_load_safe_path = xstrdup (DEFAULT_AUTO_LOAD_SAFE_PATH);
1019 auto_load_safe_path_vec_update ();
1020 add_setshow_optional_filename_cmd ("safe-path", class_support,
1021 &auto_load_safe_path, _("\
1022 Set the list of directories from which it is safe to auto-load files."), _("\
1023 Show the list of directories from which it is safe to auto-load files."), _("\
1024 Various files loaded automatically for the 'set auto-load ...' options must\n\
1025 be located in one of the directories listed by this option. Warning will be\n\
1026 printed and file will not be used otherwise. Use empty string (or even\n\
1027 empty directory entry) to allow any file for the 'set auto-load ...' options.\n\
1028 This option is ignored for the kinds of files having 'set auto-load ... off'.\n\
1029 This options has security implications for untrusted inferiors."),
1030 set_auto_load_safe_path,
1031 show_auto_load_safe_path,
1032 auto_load_set_cmdlist_get (),
1033 auto_load_show_cmdlist_get ());
1035 cmd = add_cmd ("add-auto-load-safe-path", class_support,
1036 add_auto_load_safe_path,
1037 _("Add entries to the list of directories from which it is safe "
1038 "to auto-load files.\n\
1039 See the commands 'set auto-load safe-path' and 'show auto-load safe-path' to\n\
1040 access the current full list setting."),
1042 set_cmd_completer (cmd, filename_completer);
1044 add_setshow_boolean_cmd ("auto-load", class_maintenance,
1045 &debug_auto_load, _("\
1046 Set auto-load verifications debugging."), _("\
1047 Show auto-load verifications debugging."), _("\
1048 When non-zero, debugging output for files of 'set auto-load ...'\n\
1050 NULL, show_debug_auto_load,
1051 &setdebuglist, &showdebuglist);