1 /* GDB routines for supporting auto-loaded scripts.
3 Copyright (C) 2012-2018 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/>. */
22 #include "auto-load.h"
23 #include "progspace.h"
24 #include "gdb_regex.h"
26 #include "filenames.h"
28 #include "observable.h"
30 #include "cli/cli-script.h"
32 #include "cli/cli-cmds.h"
33 #include "cli/cli-decode.h"
34 #include "cli/cli-setshow.h"
35 #include "readline/tilde.h"
36 #include "completer.h"
39 #include "filestuff.h"
40 #include "extension.h"
41 #include "gdb/section-scripts.h"
43 #include "common/pathstuff.h"
45 /* The section to look in for auto-loaded scripts (in file formats that
47 Each entry in this section is a record that begins with a leading byte
48 identifying the record type.
49 At the moment we only support one record type: A leading byte of 1,
50 followed by the path of a python script to load. */
51 #define AUTO_SECTION_NAME ".debug_gdb_scripts"
53 static void maybe_print_unsupported_script_warning
54 (struct auto_load_pspace_info *, struct objfile *objfile,
55 const struct extension_language_defn *language,
56 const char *section_name, unsigned offset);
58 static void maybe_print_script_not_found_warning
59 (struct auto_load_pspace_info *, struct objfile *objfile,
60 const struct extension_language_defn *language,
61 const char *section_name, unsigned offset);
63 /* Value of the 'set debug auto-load' configuration variable. */
64 static int debug_auto_load = 0;
66 /* "show" command for the debug_auto_load configuration variable. */
69 show_debug_auto_load (struct ui_file *file, int from_tty,
70 struct cmd_list_element *c, const char *value)
72 fprintf_filtered (file, _("Debugging output for files "
73 "of 'set auto-load ...' is %s.\n"),
77 /* User-settable option to enable/disable auto-loading of GDB_AUTO_FILE_NAME
79 set auto-load gdb-scripts on|off
80 This is true if we should auto-load associated scripts when an objfile
81 is opened, false otherwise. */
82 static int auto_load_gdb_scripts = 1;
84 /* "show" command for the auto_load_gdb_scripts configuration variable. */
87 show_auto_load_gdb_scripts (struct ui_file *file, int from_tty,
88 struct cmd_list_element *c, const char *value)
90 fprintf_filtered (file, _("Auto-loading of canned sequences of commands "
95 /* Return non-zero if auto-loading gdb scripts is enabled. */
98 auto_load_gdb_scripts_enabled (const struct extension_language_defn *extlang)
100 return auto_load_gdb_scripts;
103 /* Internal-use flag to enable/disable auto-loading.
104 This is true if we should auto-load python code when an objfile is opened,
107 Both auto_load_scripts && global_auto_load must be true to enable
110 This flag exists to facilitate deferring auto-loading during start-up
111 until after ./.gdbinit has been read; it may augment the search directories
112 used to find the scripts. */
113 int global_auto_load = 1;
115 /* Auto-load .gdbinit file from the current directory? */
116 int auto_load_local_gdbinit = 1;
118 /* Absolute pathname to the current directory .gdbinit, if it exists. */
119 char *auto_load_local_gdbinit_pathname = NULL;
121 /* Boolean value if AUTO_LOAD_LOCAL_GDBINIT_PATHNAME has been loaded. */
122 int auto_load_local_gdbinit_loaded = 0;
124 /* "show" command for the auto_load_local_gdbinit configuration variable. */
127 show_auto_load_local_gdbinit (struct ui_file *file, int from_tty,
128 struct cmd_list_element *c, const char *value)
130 fprintf_filtered (file, _("Auto-loading of .gdbinit script from current "
131 "directory is %s.\n"),
135 /* Directory list from which to load auto-loaded scripts. It is not checked
136 for absolute paths but they are strongly recommended. It is initialized by
137 _initialize_auto_load. */
138 static char *auto_load_dir;
140 /* "set" command for the auto_load_dir configuration variable. */
143 set_auto_load_dir (const char *args, int from_tty, struct cmd_list_element *c)
145 /* Setting the variable to "" resets it to the compile time defaults. */
146 if (auto_load_dir[0] == '\0')
148 xfree (auto_load_dir);
149 auto_load_dir = xstrdup (AUTO_LOAD_DIR);
153 /* "show" command for the auto_load_dir configuration variable. */
156 show_auto_load_dir (struct ui_file *file, int from_tty,
157 struct cmd_list_element *c, const char *value)
159 fprintf_filtered (file, _("List of directories from which to load "
160 "auto-loaded scripts is %s.\n"),
164 /* Directory list safe to hold auto-loaded files. It is not checked for
165 absolute paths but they are strongly recommended. It is initialized by
166 _initialize_auto_load. */
167 static char *auto_load_safe_path;
169 /* Vector of directory elements of AUTO_LOAD_SAFE_PATH with each one normalized
170 by tilde_expand and possibly each entries has added its gdb_realpath
172 std::vector<gdb::unique_xmalloc_ptr<char>> auto_load_safe_path_vec;
174 /* Expand $datadir and $debugdir in STRING according to the rules of
175 substitute_path_component. */
177 static std::vector<gdb::unique_xmalloc_ptr<char>>
178 auto_load_expand_dir_vars (const char *string)
180 char *s = xstrdup (string);
181 substitute_path_component (&s, "$datadir", gdb_datadir);
182 substitute_path_component (&s, "$debugdir", debug_file_directory);
184 if (debug_auto_load && strcmp (s, string) != 0)
185 fprintf_unfiltered (gdb_stdlog,
186 _("auto-load: Expanded $-variables to \"%s\".\n"), s);
188 std::vector<gdb::unique_xmalloc_ptr<char>> dir_vec
189 = dirnames_to_char_ptr_vec (s);
195 /* Update auto_load_safe_path_vec from current AUTO_LOAD_SAFE_PATH. */
198 auto_load_safe_path_vec_update (void)
204 fprintf_unfiltered (gdb_stdlog,
205 _("auto-load: Updating directories of \"%s\".\n"),
206 auto_load_safe_path);
208 auto_load_safe_path_vec = auto_load_expand_dir_vars (auto_load_safe_path);
210 /* Apply tilde_expand and gdb_realpath to each AUTO_LOAD_SAFE_PATH_VEC
212 for (gdb::unique_xmalloc_ptr<char> &in_vec : auto_load_safe_path_vec)
214 gdb::unique_xmalloc_ptr<char> expanded (tilde_expand (in_vec.get ()));
215 gdb::unique_xmalloc_ptr<char> real_path = gdb_realpath (expanded.get ());
217 /* Ensure the current entry is at least tilde_expand-ed. ORIGINAL makes
218 sure we free the original string. */
219 gdb::unique_xmalloc_ptr<char> original = std::move (in_vec);
220 in_vec = std::move (expanded);
224 if (strcmp (in_vec.get (), original.get ()) == 0)
225 fprintf_unfiltered (gdb_stdlog,
226 _("auto-load: Using directory \"%s\".\n"),
229 fprintf_unfiltered (gdb_stdlog,
230 _("auto-load: Resolved directory \"%s\" "
232 original.get (), in_vec.get ());
235 /* If gdb_realpath returns a different content, append it. */
236 if (strcmp (real_path.get (), in_vec.get ()) != 0)
239 fprintf_unfiltered (gdb_stdlog,
240 _("auto-load: And canonicalized as \"%s\".\n"),
243 auto_load_safe_path_vec.push_back (std::move (real_path));
248 /* Variable gdb_datadir has been set. Update content depending on $datadir. */
251 auto_load_gdb_datadir_changed (void)
253 auto_load_safe_path_vec_update ();
256 /* "set" command for the auto_load_safe_path configuration variable. */
259 set_auto_load_safe_path (const char *args,
260 int from_tty, struct cmd_list_element *c)
262 /* Setting the variable to "" resets it to the compile time defaults. */
263 if (auto_load_safe_path[0] == '\0')
265 xfree (auto_load_safe_path);
266 auto_load_safe_path = xstrdup (AUTO_LOAD_SAFE_PATH);
269 auto_load_safe_path_vec_update ();
272 /* "show" command for the auto_load_safe_path configuration variable. */
275 show_auto_load_safe_path (struct ui_file *file, int from_tty,
276 struct cmd_list_element *c, const char *value)
280 /* Check if user has entered either "/" or for example ":".
281 But while more complicate content like ":/foo" would still also
282 permit any location do not hide those. */
284 for (cs = value; *cs && (*cs == DIRNAME_SEPARATOR || IS_DIR_SEPARATOR (*cs));
287 fprintf_filtered (file, _("Auto-load files are safe to load from any "
290 fprintf_filtered (file, _("List of directories from which it is safe to "
291 "auto-load files is %s.\n"),
295 /* "add-auto-load-safe-path" command for the auto_load_safe_path configuration
299 add_auto_load_safe_path (const char *args, int from_tty)
303 if (args == NULL || *args == 0)
305 Directory argument required.\n\
306 Use 'set auto-load safe-path /' for disabling the auto-load safe-path security.\
309 s = xstrprintf ("%s%c%s", auto_load_safe_path, DIRNAME_SEPARATOR, args);
310 xfree (auto_load_safe_path);
311 auto_load_safe_path = s;
313 auto_load_safe_path_vec_update ();
316 /* "add-auto-load-scripts-directory" command for the auto_load_dir configuration
320 add_auto_load_dir (const char *args, int from_tty)
324 if (args == NULL || *args == 0)
325 error (_("Directory argument required."));
327 s = xstrprintf ("%s%c%s", auto_load_dir, DIRNAME_SEPARATOR, args);
328 xfree (auto_load_dir);
332 /* Implementation for filename_is_in_pattern overwriting the caller's FILENAME
336 filename_is_in_pattern_1 (char *filename, char *pattern)
338 size_t pattern_len = strlen (pattern);
339 size_t filename_len = strlen (filename);
342 fprintf_unfiltered (gdb_stdlog, _("auto-load: Matching file \"%s\" "
343 "to pattern \"%s\"\n"),
346 /* Trim trailing slashes ("/") from PATTERN. Even for "d:\" paths as
347 trailing slashes are trimmed also from FILENAME it still matches
349 while (pattern_len && IS_DIR_SEPARATOR (pattern[pattern_len - 1]))
351 pattern[pattern_len] = '\0';
353 /* Ensure auto_load_safe_path "/" matches any FILENAME. On MS-Windows
354 platform FILENAME even after gdb_realpath does not have to start with
355 IS_DIR_SEPARATOR character, such as the 'C:\x.exe' filename. */
356 if (pattern_len == 0)
359 fprintf_unfiltered (gdb_stdlog,
360 _("auto-load: Matched - empty pattern\n"));
366 /* Trim trailing slashes ("/"). PATTERN also has slashes trimmed the
367 same way so they will match. */
368 while (filename_len && IS_DIR_SEPARATOR (filename[filename_len - 1]))
370 filename[filename_len] = '\0';
371 if (filename_len == 0)
374 fprintf_unfiltered (gdb_stdlog,
375 _("auto-load: Not matched - pattern \"%s\".\n"),
380 if (gdb_filename_fnmatch (pattern, filename, FNM_FILE_NAME | FNM_NOESCAPE)
384 fprintf_unfiltered (gdb_stdlog, _("auto-load: Matched - file "
385 "\"%s\" to pattern \"%s\".\n"),
390 /* Trim trailing FILENAME component. */
391 while (filename_len > 0 && !IS_DIR_SEPARATOR (filename[filename_len - 1]))
396 /* Return 1 if FILENAME matches PATTERN or if FILENAME resides in
397 a subdirectory of a directory that matches PATTERN. Return 0 otherwise.
398 gdb_realpath normalization is never done here. */
400 static ATTRIBUTE_PURE int
401 filename_is_in_pattern (const char *filename, const char *pattern)
403 char *filename_copy, *pattern_copy;
405 filename_copy = (char *) alloca (strlen (filename) + 1);
406 strcpy (filename_copy, filename);
407 pattern_copy = (char *) alloca (strlen (pattern) + 1);
408 strcpy (pattern_copy, pattern);
410 return filename_is_in_pattern_1 (filename_copy, pattern_copy);
413 /* Return 1 if FILENAME belongs to one of directory components of
414 AUTO_LOAD_SAFE_PATH_VEC. Return 0 otherwise.
415 auto_load_safe_path_vec_update is never called.
416 *FILENAME_REALP may be updated by gdb_realpath of FILENAME. */
419 filename_is_in_auto_load_safe_path_vec (const char *filename,
420 gdb::unique_xmalloc_ptr<char> *filename_realp)
422 const char *pattern = NULL;
424 for (const gdb::unique_xmalloc_ptr<char> &p : auto_load_safe_path_vec)
425 if (*filename_realp == NULL && filename_is_in_pattern (filename, p.get ()))
433 if (*filename_realp == NULL)
435 *filename_realp = gdb_realpath (filename);
436 if (debug_auto_load && strcmp (filename_realp->get (), filename) != 0)
437 fprintf_unfiltered (gdb_stdlog,
438 _("auto-load: Resolved "
439 "file \"%s\" as \"%s\".\n"),
440 filename, filename_realp->get ());
443 if (strcmp (filename_realp->get (), filename) != 0)
444 for (const gdb::unique_xmalloc_ptr<char> &p : auto_load_safe_path_vec)
445 if (filename_is_in_pattern (filename_realp->get (), p.get ()))
455 fprintf_unfiltered (gdb_stdlog, _("auto-load: File \"%s\" matches "
456 "directory \"%s\".\n"),
464 /* Return 1 if FILENAME is located in one of the directories of
465 AUTO_LOAD_SAFE_PATH. Otherwise call warning and return 0. FILENAME does
466 not have to be an absolute path.
468 Existence of FILENAME is not checked. Function will still give a warning
469 even if the caller would quietly skip non-existing file in unsafe
473 file_is_auto_load_safe (const char *filename, const char *debug_fmt, ...)
475 gdb::unique_xmalloc_ptr<char> filename_real;
476 static int advice_printed = 0;
482 va_start (debug_args, debug_fmt);
483 vfprintf_unfiltered (gdb_stdlog, debug_fmt, debug_args);
487 if (filename_is_in_auto_load_safe_path_vec (filename, &filename_real))
490 auto_load_safe_path_vec_update ();
491 if (filename_is_in_auto_load_safe_path_vec (filename, &filename_real))
494 warning (_("File \"%s\" auto-loading has been declined by your "
495 "`auto-load safe-path' set to \"%s\"."),
496 filename_real.get (), auto_load_safe_path);
500 const char *homedir = getenv ("HOME");
504 std::string homeinit = string_printf ("%s/%s", homedir, gdbinit);
506 printf_filtered (_("\
507 To enable execution of this file add\n\
508 \tadd-auto-load-safe-path %s\n\
509 line to your configuration file \"%s\".\n\
510 To completely disable this security protection add\n\
511 \tset auto-load safe-path /\n\
512 line to your configuration file \"%s\".\n\
513 For more information about this security protection see the\n\
514 \"Auto-loading safe path\" section in the GDB manual. E.g., run from the shell:\n\
515 \tinfo \"(gdb)Auto-loading safe path\"\n"),
516 filename_real.get (),
517 homeinit.c_str (), homeinit.c_str ());
524 /* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
525 the same script. There's no point in loading the script multiple times,
526 and there can be a lot of objfiles and scripts, so we keep track of scripts
529 struct auto_load_pspace_info
531 /* For each program space we keep track of loaded scripts, both when
532 specified as file names and as scripts to be executed directly. */
533 struct htab *loaded_script_files;
534 struct htab *loaded_script_texts;
536 /* Non-zero if we've issued the warning about an auto-load script not being
537 supported. We only want to issue this warning once. */
538 int unsupported_script_warning_printed;
540 /* Non-zero if we've issued the warning about an auto-load script not being
541 found. We only want to issue this warning once. */
542 int script_not_found_warning_printed;
545 /* Objects of this type are stored in the loaded_script hash table. */
549 /* Name as provided by the objfile. */
552 /* Full path name or NULL if script wasn't found (or was otherwise
553 inaccessible), or NULL for loaded_script_texts. */
554 const char *full_path;
556 /* Non-zero if this script has been loaded. */
559 const struct extension_language_defn *language;
562 /* Per-program-space data key. */
563 static const struct program_space_data *auto_load_pspace_data;
566 auto_load_pspace_data_cleanup (struct program_space *pspace, void *arg)
568 struct auto_load_pspace_info *info = (struct auto_load_pspace_info *) arg;
570 if (info->loaded_script_files)
571 htab_delete (info->loaded_script_files);
572 if (info->loaded_script_texts)
573 htab_delete (info->loaded_script_texts);
577 /* Get the current autoload data. If none is found yet, add it now. This
578 function always returns a valid object. */
580 static struct auto_load_pspace_info *
581 get_auto_load_pspace_data (struct program_space *pspace)
583 struct auto_load_pspace_info *info;
585 info = ((struct auto_load_pspace_info *)
586 program_space_data (pspace, auto_load_pspace_data));
589 info = XCNEW (struct auto_load_pspace_info);
590 set_program_space_data (pspace, auto_load_pspace_data, info);
596 /* Hash function for the loaded script hash. */
599 hash_loaded_script_entry (const void *data)
601 const struct loaded_script *e = (const struct loaded_script *) data;
603 return htab_hash_string (e->name) ^ htab_hash_pointer (e->language);
606 /* Equality function for the loaded script hash. */
609 eq_loaded_script_entry (const void *a, const void *b)
611 const struct loaded_script *ea = (const struct loaded_script *) a;
612 const struct loaded_script *eb = (const struct loaded_script *) b;
614 return strcmp (ea->name, eb->name) == 0 && ea->language == eb->language;
617 /* Initialize the table to track loaded scripts.
618 Each entry is hashed by the full path name. */
621 init_loaded_scripts_info (struct auto_load_pspace_info *pspace_info)
623 /* Choose 31 as the starting size of the hash table, somewhat arbitrarily.
624 Space for each entry is obtained with one malloc so we can free them
627 pspace_info->loaded_script_files = htab_create (31,
628 hash_loaded_script_entry,
629 eq_loaded_script_entry,
631 pspace_info->loaded_script_texts = htab_create (31,
632 hash_loaded_script_entry,
633 eq_loaded_script_entry,
636 pspace_info->unsupported_script_warning_printed = FALSE;
637 pspace_info->script_not_found_warning_printed = FALSE;
640 /* Wrapper on get_auto_load_pspace_data to also allocate the hash table
641 for loading scripts. */
643 struct auto_load_pspace_info *
644 get_auto_load_pspace_data_for_loading (struct program_space *pspace)
646 struct auto_load_pspace_info *info;
648 info = get_auto_load_pspace_data (pspace);
649 if (info->loaded_script_files == NULL)
650 init_loaded_scripts_info (info);
655 /* Add script file NAME in LANGUAGE to hash table of PSPACE_INFO.
656 LOADED 1 if the script has been (is going to) be loaded, 0 otherwise
657 (such as if it has not been found).
658 FULL_PATH is NULL if the script wasn't found.
659 The result is true if the script was already in the hash table. */
662 maybe_add_script_file (struct auto_load_pspace_info *pspace_info, int loaded,
663 const char *name, const char *full_path,
664 const struct extension_language_defn *language)
666 struct htab *htab = pspace_info->loaded_script_files;
667 struct loaded_script **slot, entry;
671 entry.language = language;
672 slot = (struct loaded_script **) htab_find_slot (htab, &entry, INSERT);
673 in_hash_table = *slot != NULL;
675 /* If this script is not in the hash table, add it. */
681 /* Allocate all space in one chunk so it's easier to free. */
682 *slot = ((struct loaded_script *)
683 xmalloc (sizeof (**slot)
685 + (full_path != NULL ? (strlen (full_path) + 1) : 0)));
686 p = ((char*) *slot) + sizeof (**slot);
689 if (full_path != NULL)
692 strcpy (p, full_path);
693 (*slot)->full_path = p;
696 (*slot)->full_path = NULL;
697 (*slot)->loaded = loaded;
698 (*slot)->language = language;
701 return in_hash_table;
704 /* Add script contents NAME in LANGUAGE to hash table of PSPACE_INFO.
705 LOADED 1 if the script has been (is going to) be loaded, 0 otherwise
706 (such as if it has not been found).
707 The result is true if the script was already in the hash table. */
710 maybe_add_script_text (struct auto_load_pspace_info *pspace_info,
711 int loaded, const char *name,
712 const struct extension_language_defn *language)
714 struct htab *htab = pspace_info->loaded_script_texts;
715 struct loaded_script **slot, entry;
719 entry.language = language;
720 slot = (struct loaded_script **) htab_find_slot (htab, &entry, INSERT);
721 in_hash_table = *slot != NULL;
723 /* If this script is not in the hash table, add it. */
729 /* Allocate all space in one chunk so it's easier to free. */
730 *slot = ((struct loaded_script *)
731 xmalloc (sizeof (**slot) + strlen (name) + 1));
732 p = ((char*) *slot) + sizeof (**slot);
735 (*slot)->full_path = NULL;
736 (*slot)->loaded = loaded;
737 (*slot)->language = language;
740 return in_hash_table;
743 /* Clear the table of loaded section scripts. */
746 clear_section_scripts (void)
748 struct program_space *pspace = current_program_space;
749 struct auto_load_pspace_info *info;
751 info = ((struct auto_load_pspace_info *)
752 program_space_data (pspace, auto_load_pspace_data));
753 if (info != NULL && info->loaded_script_files != NULL)
755 htab_delete (info->loaded_script_files);
756 htab_delete (info->loaded_script_texts);
757 info->loaded_script_files = NULL;
758 info->loaded_script_texts = NULL;
759 info->unsupported_script_warning_printed = FALSE;
760 info->script_not_found_warning_printed = FALSE;
764 /* Look for the auto-load script in LANGUAGE associated with OBJFILE where
765 OBJFILE's gdb_realpath is REALNAME and load it. Return 1 if we found any
766 matching script, return 0 otherwise. */
769 auto_load_objfile_script_1 (struct objfile *objfile, const char *realname,
770 const struct extension_language_defn *language)
772 const char *debugfile;
774 const char *suffix = ext_lang_auto_load_suffix (language);
776 std::string filename = std::string (realname) + suffix;
778 gdb_file_up input = gdb_fopen_cloexec (filename.c_str (), "r");
779 debugfile = filename.c_str ();
781 fprintf_unfiltered (gdb_stdlog, _("auto-load: Attempted file \"%s\" %s.\n"),
782 debugfile, input ? _("exists") : _("does not exist"));
784 std::string debugfile_holder;
787 /* Also try the same file in a subdirectory of gdb's data
790 std::vector<gdb::unique_xmalloc_ptr<char>> vec
791 = auto_load_expand_dir_vars (auto_load_dir);
794 fprintf_unfiltered (gdb_stdlog, _("auto-load: Searching 'set auto-load "
795 "scripts-directory' path \"%s\".\n"),
798 for (const gdb::unique_xmalloc_ptr<char> &dir : vec)
800 /* FILENAME is absolute, so we don't need a "/" here. */
801 debugfile_holder = dir.get () + filename;
802 debugfile = debugfile_holder.c_str ();
804 input = gdb_fopen_cloexec (debugfile, "r");
806 fprintf_unfiltered (gdb_stdlog, _("auto-load: Attempted file "
809 input ? _("exists") : _("does not exist"));
818 struct auto_load_pspace_info *pspace_info;
821 = file_is_auto_load_safe (debugfile,
822 _("auto-load: Loading %s script \"%s\""
823 " by extension for objfile \"%s\".\n"),
824 ext_lang_name (language),
825 debugfile, objfile_name (objfile));
827 /* Add this script to the hash table too so
828 "info auto-load ${lang}-scripts" can print it. */
830 = get_auto_load_pspace_data_for_loading (current_program_space);
831 maybe_add_script_file (pspace_info, is_safe, debugfile, debugfile,
834 /* To preserve existing behaviour we don't check for whether the
835 script was already in the table, and always load it.
836 It's highly unlikely that we'd ever load it twice,
837 and these scripts are required to be idempotent under multiple
841 objfile_script_sourcer_func *sourcer
842 = ext_lang_objfile_script_sourcer (language);
844 /* We shouldn't get here if support for the language isn't
845 compiled in. And the extension language is required to implement
847 gdb_assert (sourcer != NULL);
848 sourcer (language, objfile, input.get (), debugfile);
859 /* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
863 auto_load_objfile_script (struct objfile *objfile,
864 const struct extension_language_defn *language)
866 gdb::unique_xmalloc_ptr<char> realname
867 = gdb_realpath (objfile_name (objfile));
869 if (!auto_load_objfile_script_1 (objfile, realname.get (), language))
871 /* For Windows/DOS .exe executables, strip the .exe suffix, so that
872 FOO-gdb.gdb could be used for FOO.exe, and try again. */
874 size_t len = strlen (realname.get ());
875 const size_t lexe = sizeof (".exe") - 1;
877 if (len > lexe && strcasecmp (realname.get () + len - lexe, ".exe") == 0)
880 realname.get ()[len] = '\0';
882 fprintf_unfiltered (gdb_stdlog, _("auto-load: Stripped .exe suffix, "
883 "retrying with \"%s\".\n"),
885 auto_load_objfile_script_1 (objfile, realname.get (), language);
890 /* Subroutine of source_section_scripts to simplify it.
891 Load FILE as a script in extension language LANGUAGE.
892 The script is from section SECTION_NAME in OBJFILE at offset OFFSET. */
895 source_script_file (struct auto_load_pspace_info *pspace_info,
896 struct objfile *objfile,
897 const struct extension_language_defn *language,
898 const char *section_name, unsigned int offset,
902 objfile_script_sourcer_func *sourcer;
904 /* Skip this script if support is not compiled in. */
905 sourcer = ext_lang_objfile_script_sourcer (language);
908 /* We don't throw an error, the program is still debuggable. */
909 maybe_print_unsupported_script_warning (pspace_info, objfile, language,
910 section_name, offset);
911 /* We *could* still try to open it, but there's no point. */
912 maybe_add_script_file (pspace_info, 0, file, NULL, language);
916 /* Skip this script if auto-loading it has been disabled. */
917 if (!ext_lang_auto_load_enabled (language))
919 /* No message is printed, just skip it. */
923 gdb::optional<open_script> opened = find_and_open_script (file,
928 if (!file_is_auto_load_safe (opened->full_path.get (),
929 _("auto-load: Loading %s script "
930 "\"%s\" from section \"%s\" of "
931 "objfile \"%s\".\n"),
932 ext_lang_name (language),
933 opened->full_path.get (),
934 section_name, objfile_name (objfile)))
939 /* If one script isn't found it's not uncommon for more to not be
940 found either. We don't want to print a message for each script,
941 too much noise. Instead, we print the warning once and tell the
942 user how to find the list of scripts that weren't loaded.
943 We don't throw an error, the program is still debuggable.
945 IWBN if complaints.c were more general-purpose. */
947 maybe_print_script_not_found_warning (pspace_info, objfile, language,
948 section_name, offset);
951 in_hash_table = maybe_add_script_file (pspace_info, bool (opened), file,
953 ? opened->full_path.get ()
957 /* If this file is not currently loaded, load it. */
958 if (opened && !in_hash_table)
959 sourcer (language, objfile, opened->stream.get (),
960 opened->full_path.get ());
963 /* Subroutine of source_section_scripts to simplify it.
964 Execute SCRIPT as a script in extension language LANG.
965 The script is from section SECTION_NAME in OBJFILE at offset OFFSET. */
968 execute_script_contents (struct auto_load_pspace_info *pspace_info,
969 struct objfile *objfile,
970 const struct extension_language_defn *language,
971 const char *section_name, unsigned int offset,
974 objfile_script_executor_func *executor;
975 const char *newline, *script_text;
977 int is_safe, in_hash_table;
979 /* The first line of the script is the name of the script.
980 It must not contain any kind of space character. */
982 newline = strchr (script, '\n');
983 std::string name_holder;
988 /* Put the name in a buffer and validate it. */
989 name_holder = std::string (script, newline - script);
990 buf = name_holder.c_str ();
991 for (p = buf; *p != '\0'; ++p)
996 /* We don't allow nameless scripts, they're not helpful to the user. */
997 if (p != buf && *p == '\0')
1002 /* We don't throw an error, the program is still debuggable. */
1004 Missing/bad script name in entry at offset %u in section %s\n\
1006 offset, section_name, objfile_name (objfile));
1009 script_text = newline + 1;
1011 /* Skip this script if support is not compiled in. */
1012 executor = ext_lang_objfile_script_executor (language);
1013 if (executor == NULL)
1015 /* We don't throw an error, the program is still debuggable. */
1016 maybe_print_unsupported_script_warning (pspace_info, objfile, language,
1017 section_name, offset);
1018 maybe_add_script_text (pspace_info, 0, name, language);
1022 /* Skip this script if auto-loading it has been disabled. */
1023 if (!ext_lang_auto_load_enabled (language))
1025 /* No message is printed, just skip it. */
1029 is_safe = file_is_auto_load_safe (objfile_name (objfile),
1030 _("auto-load: Loading %s script "
1031 "\"%s\" from section \"%s\" of "
1032 "objfile \"%s\".\n"),
1033 ext_lang_name (language), name,
1034 section_name, objfile_name (objfile));
1036 in_hash_table = maybe_add_script_text (pspace_info, is_safe, name, language);
1038 /* If this file is not currently loaded, load it. */
1039 if (is_safe && !in_hash_table)
1040 executor (language, objfile, name, script_text);
1043 /* Load scripts specified in OBJFILE.
1044 START,END delimit a buffer containing a list of nul-terminated
1046 SECTION_NAME is used in error messages.
1048 Scripts specified as file names are found per normal "source -s" command
1049 processing. First the script is looked for in $cwd. If not found there
1050 the source search path is used.
1052 The section contains a list of path names of script files to load or
1053 actual script contents. Each entry is nul-terminated. */
1056 source_section_scripts (struct objfile *objfile, const char *section_name,
1057 const char *start, const char *end)
1060 struct auto_load_pspace_info *pspace_info;
1062 pspace_info = get_auto_load_pspace_data_for_loading (current_program_space);
1064 for (p = start; p < end; ++p)
1067 const struct extension_language_defn *language;
1068 unsigned int offset = p - start;
1073 case SECTION_SCRIPT_ID_PYTHON_FILE:
1074 case SECTION_SCRIPT_ID_PYTHON_TEXT:
1075 language = get_ext_lang_defn (EXT_LANG_PYTHON);
1077 case SECTION_SCRIPT_ID_SCHEME_FILE:
1078 case SECTION_SCRIPT_ID_SCHEME_TEXT:
1079 language = get_ext_lang_defn (EXT_LANG_GUILE);
1082 warning (_("Invalid entry in %s section"), section_name);
1083 /* We could try various heuristics to find the next valid entry,
1084 but it's safer to just punt. */
1089 while (p < end && *p != '\0')
1093 warning (_("Non-nul-terminated entry in %s at offset %u"),
1094 section_name, offset);
1095 /* Don't load/execute it. */
1101 case SECTION_SCRIPT_ID_PYTHON_FILE:
1102 case SECTION_SCRIPT_ID_SCHEME_FILE:
1105 warning (_("Empty entry in %s at offset %u"),
1106 section_name, offset);
1109 source_script_file (pspace_info, objfile, language,
1110 section_name, offset, entry);
1112 case SECTION_SCRIPT_ID_PYTHON_TEXT:
1113 case SECTION_SCRIPT_ID_SCHEME_TEXT:
1114 execute_script_contents (pspace_info, objfile, language,
1115 section_name, offset, entry);
1121 /* Load scripts specified in section SECTION_NAME of OBJFILE. */
1124 auto_load_section_scripts (struct objfile *objfile, const char *section_name)
1126 bfd *abfd = objfile->obfd;
1127 asection *scripts_sect;
1128 bfd_byte *data = NULL;
1130 scripts_sect = bfd_get_section_by_name (abfd, section_name);
1131 if (scripts_sect == NULL
1132 || (bfd_get_section_flags (abfd, scripts_sect) & SEC_HAS_CONTENTS) == 0)
1135 if (!bfd_get_full_section_contents (abfd, scripts_sect, &data))
1136 warning (_("Couldn't read %s section of %s"),
1137 section_name, bfd_get_filename (abfd));
1140 gdb::unique_xmalloc_ptr<bfd_byte> data_holder (data);
1142 char *p = (char *) data;
1143 source_section_scripts (objfile, section_name, p,
1144 p + bfd_get_section_size (scripts_sect));
1148 /* Load any auto-loaded scripts for OBJFILE. */
1151 load_auto_scripts_for_objfile (struct objfile *objfile)
1153 /* Return immediately if auto-loading has been globally disabled.
1154 This is to handle sequencing of operations during gdb startup.
1155 Also return immediately if OBJFILE was not created from a file
1156 on the local filesystem. */
1157 if (!global_auto_load
1158 || (objfile->flags & OBJF_NOT_FILENAME) != 0
1159 || is_target_filename (objfile->original_name))
1162 /* Load any extension language scripts for this objfile.
1163 E.g., foo-gdb.gdb, foo-gdb.py. */
1164 auto_load_ext_lang_scripts_for_objfile (objfile);
1166 /* Load any scripts mentioned in AUTO_SECTION_NAME (.debug_gdb_scripts). */
1167 auto_load_section_scripts (objfile, AUTO_SECTION_NAME);
1170 /* This is a new_objfile observer callback to auto-load scripts.
1172 Two flavors of auto-loaded scripts are supported.
1173 1) based on the path to the objfile
1174 2) from .debug_gdb_scripts section */
1177 auto_load_new_objfile (struct objfile *objfile)
1181 /* OBJFILE is NULL when loading a new "main" symbol-file. */
1182 clear_section_scripts ();
1186 load_auto_scripts_for_objfile (objfile);
1189 /* Collect scripts to be printed in a vec. */
1191 struct collect_matching_scripts_data
1193 collect_matching_scripts_data (std::vector<loaded_script *> *scripts_p_,
1194 const extension_language_defn *language_)
1195 : scripts_p (scripts_p_), language (language_)
1198 std::vector<loaded_script *> *scripts_p;
1199 const struct extension_language_defn *language;
1202 /* Traversal function for htab_traverse.
1203 Collect the entry if it matches the regexp. */
1206 collect_matching_scripts (void **slot, void *info)
1208 struct loaded_script *script = (struct loaded_script *) *slot;
1209 struct collect_matching_scripts_data *data
1210 = (struct collect_matching_scripts_data *) info;
1212 if (script->language == data->language && re_exec (script->name))
1213 data->scripts_p->push_back (script);
1221 print_script (struct loaded_script *script)
1223 struct ui_out *uiout = current_uiout;
1225 ui_out_emit_tuple tuple_emitter (uiout, NULL);
1227 uiout->field_string ("loaded", script->loaded ? "Yes" : "No");
1228 uiout->field_string ("script", script->name);
1231 /* If the name isn't the full path, print it too. */
1232 if (script->full_path != NULL
1233 && strcmp (script->name, script->full_path) != 0)
1235 uiout->text ("\tfull name: ");
1236 uiout->field_string ("full_path", script->full_path);
1241 /* Helper for info_auto_load_scripts to sort the scripts by name. */
1244 sort_scripts_by_name (loaded_script *a, loaded_script *b)
1246 return FILENAME_CMP (a->name, b->name) < 0;
1249 /* Special internal GDB value of auto_load_info_scripts's PATTERN identify
1250 the "info auto-load XXX" command has been executed through the general
1251 "info auto-load" invocation. Extra newline will be printed if needed. */
1252 char auto_load_info_scripts_pattern_nl[] = "";
1254 /* Subroutine of auto_load_info_scripts to simplify it.
1258 print_scripts (const std::vector<loaded_script *> &scripts)
1260 for (loaded_script *script : scripts)
1261 print_script (script);
1264 /* Implementation for "info auto-load gdb-scripts"
1265 (and "info auto-load python-scripts"). List scripts in LANGUAGE matching
1266 PATTERN. FROM_TTY is the usual GDB boolean for user interactivity. */
1269 auto_load_info_scripts (const char *pattern, int from_tty,
1270 const struct extension_language_defn *language)
1272 struct ui_out *uiout = current_uiout;
1273 struct auto_load_pspace_info *pspace_info;
1277 pspace_info = get_auto_load_pspace_data (current_program_space);
1279 if (pattern && *pattern)
1281 char *re_err = re_comp (pattern);
1284 error (_("Invalid regexp: %s"), re_err);
1291 /* We need to know the number of rows before we build the table.
1292 Plus we want to sort the scripts by name.
1293 So first traverse the hash table collecting the matching scripts. */
1295 std::vector<loaded_script *> script_files, script_texts;
1297 if (pspace_info != NULL && pspace_info->loaded_script_files != NULL)
1299 collect_matching_scripts_data data (&script_files, language);
1301 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
1302 htab_traverse_noresize (pspace_info->loaded_script_files,
1303 collect_matching_scripts, &data);
1305 std::sort (script_files.begin (), script_files.end (),
1306 sort_scripts_by_name);
1309 if (pspace_info != NULL && pspace_info->loaded_script_texts != NULL)
1311 collect_matching_scripts_data data (&script_texts, language);
1313 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
1314 htab_traverse_noresize (pspace_info->loaded_script_texts,
1315 collect_matching_scripts, &data);
1317 std::sort (script_texts.begin (), script_texts.end (),
1318 sort_scripts_by_name);
1321 int nr_scripts = script_files.size () + script_texts.size ();
1323 /* Table header shifted right by preceding "gdb-scripts: " would not match
1325 if (nr_scripts > 0 && pattern == auto_load_info_scripts_pattern_nl)
1329 ui_out_emit_table table_emitter (uiout, 2, nr_scripts,
1330 "AutoLoadedScriptsTable");
1332 uiout->table_header (7, ui_left, "loaded", "Loaded");
1333 uiout->table_header (70, ui_left, "script", "Script");
1334 uiout->table_body ();
1336 print_scripts (script_files);
1337 print_scripts (script_texts);
1340 if (nr_scripts == 0)
1342 if (pattern && *pattern)
1343 uiout->message ("No auto-load scripts matching %s.\n", pattern);
1345 uiout->message ("No auto-load scripts.\n");
1349 /* Wrapper for "info auto-load gdb-scripts". */
1352 info_auto_load_gdb_scripts (const char *pattern, int from_tty)
1354 auto_load_info_scripts (pattern, from_tty, &extension_language_gdb);
1357 /* Implement 'info auto-load local-gdbinit'. */
1360 info_auto_load_local_gdbinit (const char *args, int from_tty)
1362 if (auto_load_local_gdbinit_pathname == NULL)
1363 printf_filtered (_("Local .gdbinit file was not found.\n"));
1364 else if (auto_load_local_gdbinit_loaded)
1365 printf_filtered (_("Local .gdbinit file \"%s\" has been loaded.\n"),
1366 auto_load_local_gdbinit_pathname);
1368 printf_filtered (_("Local .gdbinit file \"%s\" has not been loaded.\n"),
1369 auto_load_local_gdbinit_pathname);
1372 /* Print an "unsupported script" warning if it has not already been printed.
1373 The script is in language LANGUAGE at offset OFFSET in section SECTION_NAME
1377 maybe_print_unsupported_script_warning
1378 (struct auto_load_pspace_info *pspace_info,
1379 struct objfile *objfile, const struct extension_language_defn *language,
1380 const char *section_name, unsigned offset)
1382 if (!pspace_info->unsupported_script_warning_printed)
1385 Unsupported auto-load script at offset %u in section %s\n\
1387 Use `info auto-load %s-scripts [REGEXP]' to list them."),
1388 offset, section_name, objfile_name (objfile),
1389 ext_lang_name (language));
1390 pspace_info->unsupported_script_warning_printed = 1;
1394 /* Return non-zero if SCRIPT_NOT_FOUND_WARNING_PRINTED of PSPACE_INFO was unset
1395 before calling this function. Always set SCRIPT_NOT_FOUND_WARNING_PRINTED
1399 maybe_print_script_not_found_warning
1400 (struct auto_load_pspace_info *pspace_info,
1401 struct objfile *objfile, const struct extension_language_defn *language,
1402 const char *section_name, unsigned offset)
1404 if (!pspace_info->script_not_found_warning_printed)
1407 Missing auto-load script at offset %u in section %s\n\
1409 Use `info auto-load %s-scripts [REGEXP]' to list them."),
1410 offset, section_name, objfile_name (objfile),
1411 ext_lang_name (language));
1412 pspace_info->script_not_found_warning_printed = 1;
1416 /* The only valid "set auto-load" argument is off|0|no|disable. */
1419 set_auto_load_cmd (const char *args, int from_tty)
1421 struct cmd_list_element *list;
1424 /* See parse_binary_operation in use by the sub-commands. */
1426 length = args ? strlen (args) : 0;
1428 while (length > 0 && (args[length - 1] == ' ' || args[length - 1] == '\t'))
1431 if (length == 0 || (strncmp (args, "off", length) != 0
1432 && strncmp (args, "0", length) != 0
1433 && strncmp (args, "no", length) != 0
1434 && strncmp (args, "disable", length) != 0))
1435 error (_("Valid is only global 'set auto-load no'; "
1436 "otherwise check the auto-load sub-commands."));
1438 for (list = *auto_load_set_cmdlist_get (); list != NULL; list = list->next)
1439 if (list->var_type == var_boolean)
1441 gdb_assert (list->type == set_cmd);
1442 do_set_command (args, from_tty, list);
1446 /* Initialize "set auto-load " commands prefix and return it. */
1448 struct cmd_list_element **
1449 auto_load_set_cmdlist_get (void)
1451 static struct cmd_list_element *retval;
1454 add_prefix_cmd ("auto-load", class_maintenance, set_auto_load_cmd, _("\
1455 Auto-loading specific settings.\n\
1456 Configure various auto-load-specific variables such as\n\
1457 automatic loading of Python scripts."),
1458 &retval, "set auto-load ",
1459 1/*allow-unknown*/, &setlist);
1464 /* Command "show auto-load" displays summary of all the current
1465 "show auto-load " settings. */
1468 show_auto_load_cmd (const char *args, int from_tty)
1470 cmd_show_list (*auto_load_show_cmdlist_get (), from_tty, "");
1473 /* Initialize "show auto-load " commands prefix and return it. */
1475 struct cmd_list_element **
1476 auto_load_show_cmdlist_get (void)
1478 static struct cmd_list_element *retval;
1481 add_prefix_cmd ("auto-load", class_maintenance, show_auto_load_cmd, _("\
1482 Show auto-loading specific settings.\n\
1483 Show configuration of various auto-load-specific variables such as\n\
1484 automatic loading of Python scripts."),
1485 &retval, "show auto-load ",
1486 0/*allow-unknown*/, &showlist);
1491 /* Command "info auto-load" displays whether the various auto-load files have
1492 been loaded. This is reimplementation of cmd_show_list which inserts
1493 newlines at proper places. */
1496 info_auto_load_cmd (const char *args, int from_tty)
1498 struct cmd_list_element *list;
1499 struct ui_out *uiout = current_uiout;
1501 ui_out_emit_tuple tuple_emitter (uiout, "infolist");
1503 for (list = *auto_load_info_cmdlist_get (); list != NULL; list = list->next)
1505 ui_out_emit_tuple option_emitter (uiout, "option");
1507 gdb_assert (!list->prefixlist);
1508 gdb_assert (list->type == not_set_cmd);
1510 uiout->field_string ("name", list->name);
1512 cmd_func (list, auto_load_info_scripts_pattern_nl, from_tty);
1516 /* Initialize "info auto-load " commands prefix and return it. */
1518 struct cmd_list_element **
1519 auto_load_info_cmdlist_get (void)
1521 static struct cmd_list_element *retval;
1524 add_prefix_cmd ("auto-load", class_info, info_auto_load_cmd, _("\
1525 Print current status of auto-loaded files.\n\
1526 Print whether various files like Python scripts or .gdbinit files have been\n\
1527 found and/or loaded."),
1528 &retval, "info auto-load ",
1529 0/*allow-unknown*/, &infolist);
1535 _initialize_auto_load (void)
1537 struct cmd_list_element *cmd;
1538 char *scripts_directory_help, *gdb_name_help, *python_name_help;
1539 char *guile_name_help;
1542 auto_load_pspace_data
1543 = register_program_space_data_with_cleanup (NULL,
1544 auto_load_pspace_data_cleanup);
1546 gdb::observers::new_objfile.attach (auto_load_new_objfile);
1548 add_setshow_boolean_cmd ("gdb-scripts", class_support,
1549 &auto_load_gdb_scripts, _("\
1550 Enable or disable auto-loading of canned sequences of commands scripts."), _("\
1551 Show whether auto-loading of canned sequences of commands scripts is enabled."),
1553 If enabled, canned sequences of commands are loaded when the debugger reads\n\
1554 an executable or shared library.\n\
1555 This options has security implications for untrusted inferiors."),
1556 NULL, show_auto_load_gdb_scripts,
1557 auto_load_set_cmdlist_get (),
1558 auto_load_show_cmdlist_get ());
1560 add_cmd ("gdb-scripts", class_info, info_auto_load_gdb_scripts,
1561 _("Print the list of automatically loaded sequences of commands.\n\
1562 Usage: info auto-load gdb-scripts [REGEXP]"),
1563 auto_load_info_cmdlist_get ());
1565 add_setshow_boolean_cmd ("local-gdbinit", class_support,
1566 &auto_load_local_gdbinit, _("\
1567 Enable or disable auto-loading of .gdbinit script in current directory."), _("\
1568 Show whether auto-loading .gdbinit script in current directory is enabled."),
1570 If enabled, canned sequences of commands are loaded when debugger starts\n\
1571 from .gdbinit file in current directory. Such files are deprecated,\n\
1572 use a script associated with inferior executable file instead.\n\
1573 This options has security implications for untrusted inferiors."),
1574 NULL, show_auto_load_local_gdbinit,
1575 auto_load_set_cmdlist_get (),
1576 auto_load_show_cmdlist_get ());
1578 add_cmd ("local-gdbinit", class_info, info_auto_load_local_gdbinit,
1579 _("Print whether current directory .gdbinit file has been loaded.\n\
1580 Usage: info auto-load local-gdbinit"),
1581 auto_load_info_cmdlist_get ());
1583 auto_load_dir = xstrdup (AUTO_LOAD_DIR);
1585 suffix = ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GDB));
1588 GDB scripts: OBJFILE%s\n"),
1590 python_name_help = NULL;
1592 suffix = ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_PYTHON));
1595 Python scripts: OBJFILE%s\n"),
1598 guile_name_help = NULL;
1600 suffix = ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GUILE));
1603 Guile scripts: OBJFILE%s\n"),
1606 scripts_directory_help
1608 Automatically loaded scripts are located in one of the directories listed\n\
1614 This option is ignored for the kinds of scripts \
1615 having 'set auto-load ... off'.\n\
1616 Directories listed here need to be present also \
1617 in the 'set auto-load safe-path'\n\
1620 python_name_help ? python_name_help : "",
1621 guile_name_help ? guile_name_help : "");
1623 add_setshow_optional_filename_cmd ("scripts-directory", class_support,
1624 &auto_load_dir, _("\
1625 Set the list of directories from which to load auto-loaded scripts."), _("\
1626 Show the list of directories from which to load auto-loaded scripts."),
1627 scripts_directory_help,
1628 set_auto_load_dir, show_auto_load_dir,
1629 auto_load_set_cmdlist_get (),
1630 auto_load_show_cmdlist_get ());
1631 xfree (scripts_directory_help);
1632 xfree (python_name_help);
1633 xfree (gdb_name_help);
1634 xfree (guile_name_help);
1636 auto_load_safe_path = xstrdup (AUTO_LOAD_SAFE_PATH);
1637 auto_load_safe_path_vec_update ();
1638 add_setshow_optional_filename_cmd ("safe-path", class_support,
1639 &auto_load_safe_path, _("\
1640 Set the list of files and directories that are safe for auto-loading."), _("\
1641 Show the list of files and directories that are safe for auto-loading."), _("\
1642 Various files loaded automatically for the 'set auto-load ...' options must\n\
1643 be located in one of the directories listed by this option. Warning will be\n\
1644 printed and file will not be used otherwise.\n\
1645 You can mix both directory and filename entries.\n\
1646 Setting this parameter to an empty list resets it to its default value.\n\
1647 Setting this parameter to '/' (without the quotes) allows any file\n\
1648 for the 'set auto-load ...' options. Each path entry can be also shell\n\
1649 wildcard pattern; '*' does not match directory separator.\n\
1650 This option is ignored for the kinds of files having 'set auto-load ... off'.\n\
1651 This options has security implications for untrusted inferiors."),
1652 set_auto_load_safe_path,
1653 show_auto_load_safe_path,
1654 auto_load_set_cmdlist_get (),
1655 auto_load_show_cmdlist_get ());
1656 gdb::observers::gdb_datadir_changed.attach (auto_load_gdb_datadir_changed);
1658 cmd = add_cmd ("add-auto-load-safe-path", class_support,
1659 add_auto_load_safe_path,
1660 _("Add entries to the list of directories from which it is safe "
1661 "to auto-load files.\n\
1662 See the commands 'set auto-load safe-path' and 'show auto-load safe-path' to\n\
1663 access the current full list setting."),
1665 set_cmd_completer (cmd, filename_completer);
1667 cmd = add_cmd ("add-auto-load-scripts-directory", class_support,
1669 _("Add entries to the list of directories from which to load "
1670 "auto-loaded scripts.\n\
1671 See the commands 'set auto-load scripts-directory' and\n\
1672 'show auto-load scripts-directory' to access the current full list setting."),
1674 set_cmd_completer (cmd, filename_completer);
1676 add_setshow_boolean_cmd ("auto-load", class_maintenance,
1677 &debug_auto_load, _("\
1678 Set auto-load verifications debugging."), _("\
1679 Show auto-load verifications debugging."), _("\
1680 When non-zero, debugging output for files of 'set auto-load ...'\n\
1682 NULL, show_debug_auto_load,
1683 &setdebuglist, &showdebuglist);