1 /* GDB routines for supporting auto-loaded scripts.
3 Copyright (C) 2012-2022 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 "gdbsupport/filestuff.h"
40 #include "extension.h"
41 #include "gdb/section-scripts.h"
43 #include "gdbsupport/pathstuff.h"
44 #include "cli/cli-style.h"
46 /* The section to look in for auto-loaded scripts (in file formats that
48 Each entry in this section is a record that begins with a leading byte
49 identifying the record type.
50 At the moment we only support one record type: A leading byte of 1,
51 followed by the path of a python script to load. */
52 #define AUTO_SECTION_NAME ".debug_gdb_scripts"
54 static void maybe_print_unsupported_script_warning
55 (struct auto_load_pspace_info
*, struct objfile
*objfile
,
56 const struct extension_language_defn
*language
,
57 const char *section_name
, unsigned offset
);
59 static void maybe_print_script_not_found_warning
60 (struct auto_load_pspace_info
*, struct objfile
*objfile
,
61 const struct extension_language_defn
*language
,
62 const char *section_name
, unsigned offset
);
64 /* See auto-load.h. */
66 bool debug_auto_load
= false;
68 /* "show" command for the debug_auto_load configuration variable. */
71 show_debug_auto_load (struct ui_file
*file
, int from_tty
,
72 struct cmd_list_element
*c
, const char *value
)
74 fprintf_filtered (file
, _("Debugging output for files "
75 "of 'set auto-load ...' is %s.\n"),
79 /* User-settable option to enable/disable auto-loading of GDB_AUTO_FILE_NAME
81 set auto-load gdb-scripts on|off
82 This is true if we should auto-load associated scripts when an objfile
83 is opened, false otherwise. */
84 static bool auto_load_gdb_scripts
= true;
86 /* "show" command for the auto_load_gdb_scripts configuration variable. */
89 show_auto_load_gdb_scripts (struct ui_file
*file
, int from_tty
,
90 struct cmd_list_element
*c
, const char *value
)
92 fprintf_filtered (file
, _("Auto-loading of canned sequences of commands "
97 /* See auto-load.h. */
100 auto_load_gdb_scripts_enabled (const struct extension_language_defn
*extlang
)
102 return auto_load_gdb_scripts
;
105 /* Internal-use flag to enable/disable auto-loading.
106 This is true if we should auto-load python code when an objfile is opened,
109 Both auto_load_scripts && global_auto_load must be true to enable
112 This flag exists to facilitate deferring auto-loading during start-up
113 until after ./.gdbinit has been read; it may augment the search directories
114 used to find the scripts. */
115 bool global_auto_load
= true;
117 /* Auto-load .gdbinit file from the current directory? */
118 bool auto_load_local_gdbinit
= true;
120 /* Absolute pathname to the current directory .gdbinit, if it exists. */
121 char *auto_load_local_gdbinit_pathname
= NULL
;
123 /* if AUTO_LOAD_LOCAL_GDBINIT_PATHNAME has been loaded. */
124 bool auto_load_local_gdbinit_loaded
= false;
126 /* "show" command for the auto_load_local_gdbinit configuration variable. */
129 show_auto_load_local_gdbinit (struct ui_file
*file
, int from_tty
,
130 struct cmd_list_element
*c
, const char *value
)
132 fprintf_filtered (file
, _("Auto-loading of .gdbinit script from current "
133 "directory is %s.\n"),
137 /* Directory list from which to load auto-loaded scripts. It is not checked
138 for absolute paths but they are strongly recommended. It is initialized by
139 _initialize_auto_load. */
140 static std::string auto_load_dir
= AUTO_LOAD_DIR
;
142 /* "set" command for the auto_load_dir configuration variable. */
145 set_auto_load_dir (const char *args
, int from_tty
, struct cmd_list_element
*c
)
147 /* Setting the variable to "" resets it to the compile time defaults. */
148 if (auto_load_dir
.empty ())
149 auto_load_dir
= AUTO_LOAD_DIR
;
152 /* "show" command for the auto_load_dir configuration variable. */
155 show_auto_load_dir (struct ui_file
*file
, int from_tty
,
156 struct cmd_list_element
*c
, const char *value
)
158 fprintf_filtered (file
, _("List of directories from which to load "
159 "auto-loaded scripts is %s.\n"),
163 /* Directory list safe to hold auto-loaded files. It is not checked for
164 absolute paths but they are strongly recommended. It is initialized by
165 _initialize_auto_load. */
166 static std::string auto_load_safe_path
= AUTO_LOAD_SAFE_PATH
;
168 /* Vector of directory elements of AUTO_LOAD_SAFE_PATH with each one normalized
169 by tilde_expand and possibly each entries has added its gdb_realpath
171 static std::vector
<gdb::unique_xmalloc_ptr
<char>> auto_load_safe_path_vec
;
173 /* Expand $datadir and $debugdir in STRING according to the rules of
174 substitute_path_component. */
176 static std::vector
<gdb::unique_xmalloc_ptr
<char>>
177 auto_load_expand_dir_vars (const char *string
)
179 char *s
= xstrdup (string
);
180 substitute_path_component (&s
, "$datadir", gdb_datadir
.c_str ());
181 substitute_path_component (&s
, "$debugdir", debug_file_directory
.c_str ());
183 if (debug_auto_load
&& strcmp (s
, string
) != 0)
184 auto_load_debug_printf ("Expanded $-variables to \"%s\".", s
);
186 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
187 = dirnames_to_char_ptr_vec (s
);
193 /* Update auto_load_safe_path_vec from current AUTO_LOAD_SAFE_PATH. */
196 auto_load_safe_path_vec_update (void)
198 auto_load_debug_printf ("Updating directories of \"%s\".",
199 auto_load_safe_path
.c_str ());
201 auto_load_safe_path_vec
202 = auto_load_expand_dir_vars (auto_load_safe_path
.c_str ());
203 size_t len
= auto_load_safe_path_vec
.size ();
205 /* Apply tilde_expand and gdb_realpath to each AUTO_LOAD_SAFE_PATH_VEC
207 for (size_t i
= 0; i
< len
; i
++)
209 gdb::unique_xmalloc_ptr
<char> &in_vec
= auto_load_safe_path_vec
[i
];
210 gdb::unique_xmalloc_ptr
<char> expanded (tilde_expand (in_vec
.get ()));
211 gdb::unique_xmalloc_ptr
<char> real_path
= gdb_realpath (expanded
.get ());
213 /* Ensure the current entry is at least tilde_expand-ed. ORIGINAL makes
214 sure we free the original string. */
215 gdb::unique_xmalloc_ptr
<char> original
= std::move (in_vec
);
216 in_vec
= std::move (expanded
);
220 if (strcmp (in_vec
.get (), original
.get ()) == 0)
221 auto_load_debug_printf ("Using directory \"%s\".",
224 auto_load_debug_printf ("Resolved directory \"%s\" as \"%s\".",
225 original
.get (), in_vec
.get ());
228 /* If gdb_realpath returns a different content, append it. */
229 if (strcmp (real_path
.get (), in_vec
.get ()) != 0)
231 auto_load_debug_printf ("And canonicalized as \"%s\".",
234 auto_load_safe_path_vec
.push_back (std::move (real_path
));
239 /* Variable gdb_datadir has been set. Update content depending on $datadir. */
242 auto_load_gdb_datadir_changed (void)
244 auto_load_safe_path_vec_update ();
247 /* "set" command for the auto_load_safe_path configuration variable. */
250 set_auto_load_safe_path (const char *args
,
251 int from_tty
, struct cmd_list_element
*c
)
253 /* Setting the variable to "" resets it to the compile time defaults. */
254 if (auto_load_safe_path
.empty ())
255 auto_load_safe_path
= AUTO_LOAD_SAFE_PATH
;
257 auto_load_safe_path_vec_update ();
260 /* "show" command for the auto_load_safe_path configuration variable. */
263 show_auto_load_safe_path (struct ui_file
*file
, int from_tty
,
264 struct cmd_list_element
*c
, const char *value
)
268 /* Check if user has entered either "/" or for example ":".
269 But while more complicate content like ":/foo" would still also
270 permit any location do not hide those. */
272 for (cs
= value
; *cs
&& (*cs
== DIRNAME_SEPARATOR
|| IS_DIR_SEPARATOR (*cs
));
275 fprintf_filtered (file
, _("Auto-load files are safe to load from any "
278 fprintf_filtered (file
, _("List of directories from which it is safe to "
279 "auto-load files is %s.\n"),
283 /* "add-auto-load-safe-path" command for the auto_load_safe_path configuration
287 add_auto_load_safe_path (const char *args
, int from_tty
)
289 if (args
== NULL
|| *args
== 0)
291 Directory argument required.\n\
292 Use 'set auto-load safe-path /' for disabling the auto-load safe-path security.\
295 auto_load_safe_path
= string_printf ("%s%c%s", auto_load_safe_path
.c_str (),
296 DIRNAME_SEPARATOR
, args
);
298 auto_load_safe_path_vec_update ();
301 /* "add-auto-load-scripts-directory" command for the auto_load_dir configuration
305 add_auto_load_dir (const char *args
, int from_tty
)
307 if (args
== NULL
|| *args
== 0)
308 error (_("Directory argument required."));
310 auto_load_dir
= string_printf ("%s%c%s", auto_load_dir
.c_str (),
311 DIRNAME_SEPARATOR
, args
);
314 /* Implementation for filename_is_in_pattern overwriting the caller's FILENAME
318 filename_is_in_pattern_1 (char *filename
, char *pattern
)
320 size_t pattern_len
= strlen (pattern
);
321 size_t filename_len
= strlen (filename
);
323 auto_load_debug_printf ("Matching file \"%s\" to pattern \"%s\"",
326 /* Trim trailing slashes ("/") from PATTERN. Even for "d:\" paths as
327 trailing slashes are trimmed also from FILENAME it still matches
329 while (pattern_len
&& IS_DIR_SEPARATOR (pattern
[pattern_len
- 1]))
331 pattern
[pattern_len
] = '\0';
333 /* Ensure auto_load_safe_path "/" matches any FILENAME. On MS-Windows
334 platform FILENAME even after gdb_realpath does not have to start with
335 IS_DIR_SEPARATOR character, such as the 'C:\x.exe' filename. */
336 if (pattern_len
== 0)
338 auto_load_debug_printf ("Matched - empty pattern");
344 /* Trim trailing slashes ("/"). PATTERN also has slashes trimmed the
345 same way so they will match. */
346 while (filename_len
&& IS_DIR_SEPARATOR (filename
[filename_len
- 1]))
348 filename
[filename_len
] = '\0';
349 if (filename_len
== 0)
351 auto_load_debug_printf ("Not matched - pattern \"%s\".", pattern
);
355 if (gdb_filename_fnmatch (pattern
, filename
, FNM_FILE_NAME
| FNM_NOESCAPE
)
358 auto_load_debug_printf ("Matched - file \"%s\" to pattern \"%s\".",
363 /* Trim trailing FILENAME component. */
364 while (filename_len
> 0 && !IS_DIR_SEPARATOR (filename
[filename_len
- 1]))
369 /* Return 1 if FILENAME matches PATTERN or if FILENAME resides in
370 a subdirectory of a directory that matches PATTERN. Return 0 otherwise.
371 gdb_realpath normalization is never done here. */
373 static ATTRIBUTE_PURE
int
374 filename_is_in_pattern (const char *filename
, const char *pattern
)
376 char *filename_copy
, *pattern_copy
;
378 filename_copy
= (char *) alloca (strlen (filename
) + 1);
379 strcpy (filename_copy
, filename
);
380 pattern_copy
= (char *) alloca (strlen (pattern
) + 1);
381 strcpy (pattern_copy
, pattern
);
383 return filename_is_in_pattern_1 (filename_copy
, pattern_copy
);
386 /* Return 1 if FILENAME belongs to one of directory components of
387 AUTO_LOAD_SAFE_PATH_VEC. Return 0 otherwise.
388 auto_load_safe_path_vec_update is never called.
389 *FILENAME_REALP may be updated by gdb_realpath of FILENAME. */
392 filename_is_in_auto_load_safe_path_vec (const char *filename
,
393 gdb::unique_xmalloc_ptr
<char> *filename_realp
)
395 const char *pattern
= NULL
;
397 for (const gdb::unique_xmalloc_ptr
<char> &p
: auto_load_safe_path_vec
)
398 if (*filename_realp
== NULL
&& filename_is_in_pattern (filename
, p
.get ()))
406 if (*filename_realp
== NULL
)
408 *filename_realp
= gdb_realpath (filename
);
409 if (debug_auto_load
&& strcmp (filename_realp
->get (), filename
) != 0)
410 auto_load_debug_printf ("Resolved file \"%s\" as \"%s\".",
411 filename
, filename_realp
->get ());
414 if (strcmp (filename_realp
->get (), filename
) != 0)
415 for (const gdb::unique_xmalloc_ptr
<char> &p
: auto_load_safe_path_vec
)
416 if (filename_is_in_pattern (filename_realp
->get (), p
.get ()))
425 auto_load_debug_printf ("File \"%s\" matches directory \"%s\".",
433 /* See auto-load.h. */
436 file_is_auto_load_safe (const char *filename
)
438 gdb::unique_xmalloc_ptr
<char> filename_real
;
439 static bool advice_printed
= false;
441 if (filename_is_in_auto_load_safe_path_vec (filename
, &filename_real
))
444 auto_load_safe_path_vec_update ();
445 if (filename_is_in_auto_load_safe_path_vec (filename
, &filename_real
))
448 warning (_("File \"%ps\" auto-loading has been declined by your "
449 "`auto-load safe-path' set to \"%s\"."),
450 styled_string (file_name_style
.style (), filename_real
.get ()),
451 auto_load_safe_path
.c_str ());
455 /* Find the existing home directory config file. */
457 std::string home_config
= find_gdb_home_config_file (GDBINIT
, &buf
);
458 if (home_config
.empty ())
460 /* The user doesn't have an existing home directory config file,
461 so we should suggest a suitable path for them to use. */
462 std::string config_dir_file
463 = get_standard_config_filename (GDBINIT
);
464 if (!config_dir_file
.empty ())
465 home_config
= config_dir_file
;
468 const char *homedir
= getenv ("HOME");
469 if (homedir
== nullptr)
471 home_config
= (std::string (homedir
) + SLASH_STRING
472 + std::string (GDBINIT
));
476 printf_filtered (_("\
477 To enable execution of this file add\n\
478 \tadd-auto-load-safe-path %s\n\
479 line to your configuration file \"%s\".\n\
480 To completely disable this security protection add\n\
481 \tset auto-load safe-path /\n\
482 line to your configuration file \"%s\".\n\
483 For more information about this security protection see the\n\
484 \"Auto-loading safe path\" section in the GDB manual. E.g., run from the shell:\n\
485 \tinfo \"(gdb)Auto-loading safe path\"\n"),
486 filename_real
.get (),
487 home_config
.c_str (), home_config
.c_str ());
488 advice_printed
= true;
494 /* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
495 the same script. There's no point in loading the script multiple times,
496 and there can be a lot of objfiles and scripts, so we keep track of scripts
499 struct auto_load_pspace_info
501 /* For each program space we keep track of loaded scripts, both when
502 specified as file names and as scripts to be executed directly. */
503 htab_up loaded_script_files
;
504 htab_up loaded_script_texts
;
506 /* Non-zero if we've issued the warning about an auto-load script not being
507 supported. We only want to issue this warning once. */
508 bool unsupported_script_warning_printed
= false;
510 /* Non-zero if we've issued the warning about an auto-load script not being
511 found. We only want to issue this warning once. */
512 bool script_not_found_warning_printed
= false;
515 /* Objects of this type are stored in the loaded_script hash table. */
519 /* Name as provided by the objfile. */
522 /* Full path name or NULL if script wasn't found (or was otherwise
523 inaccessible), or NULL for loaded_script_texts. */
524 const char *full_path
;
526 /* True if this script has been loaded. */
529 const struct extension_language_defn
*language
;
532 /* Per-program-space data key. */
533 static const struct program_space_key
<struct auto_load_pspace_info
>
534 auto_load_pspace_data
;
536 /* Get the current autoload data. If none is found yet, add it now. This
537 function always returns a valid object. */
539 static struct auto_load_pspace_info
*
540 get_auto_load_pspace_data (struct program_space
*pspace
)
542 struct auto_load_pspace_info
*info
;
544 info
= auto_load_pspace_data
.get (pspace
);
546 info
= auto_load_pspace_data
.emplace (pspace
);
551 /* Hash function for the loaded script hash. */
554 hash_loaded_script_entry (const void *data
)
556 const struct loaded_script
*e
= (const struct loaded_script
*) data
;
558 return htab_hash_string (e
->name
) ^ htab_hash_pointer (e
->language
);
561 /* Equality function for the loaded script hash. */
564 eq_loaded_script_entry (const void *a
, const void *b
)
566 const struct loaded_script
*ea
= (const struct loaded_script
*) a
;
567 const struct loaded_script
*eb
= (const struct loaded_script
*) b
;
569 return strcmp (ea
->name
, eb
->name
) == 0 && ea
->language
== eb
->language
;
572 /* Initialize the table to track loaded scripts.
573 Each entry is hashed by the full path name. */
576 init_loaded_scripts_info (struct auto_load_pspace_info
*pspace_info
)
578 /* Choose 31 as the starting size of the hash table, somewhat arbitrarily.
579 Space for each entry is obtained with one malloc so we can free them
582 pspace_info
->loaded_script_files
.reset
584 hash_loaded_script_entry
,
585 eq_loaded_script_entry
,
587 pspace_info
->loaded_script_texts
.reset
589 hash_loaded_script_entry
,
590 eq_loaded_script_entry
,
593 pspace_info
->unsupported_script_warning_printed
= false;
594 pspace_info
->script_not_found_warning_printed
= false;
597 /* Wrapper on get_auto_load_pspace_data to also allocate the hash table
598 for loading scripts. */
600 struct auto_load_pspace_info
*
601 get_auto_load_pspace_data_for_loading (struct program_space
*pspace
)
603 struct auto_load_pspace_info
*info
;
605 info
= get_auto_load_pspace_data (pspace
);
606 if (info
->loaded_script_files
== NULL
)
607 init_loaded_scripts_info (info
);
612 /* Add script file NAME in LANGUAGE to hash table of PSPACE_INFO.
613 LOADED is true if the script has been (is going to) be loaded, false
614 otherwise (such as if it has not been found).
615 FULL_PATH is NULL if the script wasn't found.
617 The result is true if the script was already in the hash table. */
620 maybe_add_script_file (struct auto_load_pspace_info
*pspace_info
, bool loaded
,
621 const char *name
, const char *full_path
,
622 const struct extension_language_defn
*language
)
624 struct htab
*htab
= pspace_info
->loaded_script_files
.get ();
625 struct loaded_script
**slot
, entry
;
628 entry
.language
= language
;
629 slot
= (struct loaded_script
**) htab_find_slot (htab
, &entry
, INSERT
);
630 bool in_hash_table
= *slot
!= NULL
;
632 /* If this script is not in the hash table, add it. */
638 /* Allocate all space in one chunk so it's easier to free. */
639 *slot
= ((struct loaded_script
*)
640 xmalloc (sizeof (**slot
)
642 + (full_path
!= NULL
? (strlen (full_path
) + 1) : 0)));
643 p
= ((char*) *slot
) + sizeof (**slot
);
646 if (full_path
!= NULL
)
649 strcpy (p
, full_path
);
650 (*slot
)->full_path
= p
;
653 (*slot
)->full_path
= NULL
;
654 (*slot
)->loaded
= loaded
;
655 (*slot
)->language
= language
;
658 return in_hash_table
;
661 /* Add script contents NAME in LANGUAGE to hash table of PSPACE_INFO.
662 LOADED is true if the script has been (is going to) be loaded, false
663 otherwise (such as if it has not been found).
665 The result is true if the script was already in the hash table. */
668 maybe_add_script_text (struct auto_load_pspace_info
*pspace_info
,
669 bool loaded
, const char *name
,
670 const struct extension_language_defn
*language
)
672 struct htab
*htab
= pspace_info
->loaded_script_texts
.get ();
673 struct loaded_script
**slot
, entry
;
676 entry
.language
= language
;
677 slot
= (struct loaded_script
**) htab_find_slot (htab
, &entry
, INSERT
);
678 bool in_hash_table
= *slot
!= NULL
;
680 /* If this script is not in the hash table, add it. */
686 /* Allocate all space in one chunk so it's easier to free. */
687 *slot
= ((struct loaded_script
*)
688 xmalloc (sizeof (**slot
) + strlen (name
) + 1));
689 p
= ((char*) *slot
) + sizeof (**slot
);
692 (*slot
)->full_path
= NULL
;
693 (*slot
)->loaded
= loaded
;
694 (*slot
)->language
= language
;
697 return in_hash_table
;
700 /* Clear the table of loaded section scripts. */
703 clear_section_scripts (void)
705 struct program_space
*pspace
= current_program_space
;
706 struct auto_load_pspace_info
*info
;
708 info
= auto_load_pspace_data
.get (pspace
);
709 if (info
!= NULL
&& info
->loaded_script_files
!= NULL
)
710 auto_load_pspace_data
.clear (pspace
);
713 /* Look for the auto-load script in LANGUAGE associated with OBJFILE where
714 OBJFILE's gdb_realpath is REALNAME and load it. Return 1 if we found any
715 matching script, return 0 otherwise. */
718 auto_load_objfile_script_1 (struct objfile
*objfile
, const char *realname
,
719 const struct extension_language_defn
*language
)
721 const char *debugfile
;
723 const char *suffix
= ext_lang_auto_load_suffix (language
);
725 std::string filename
= std::string (realname
) + suffix
;
727 gdb_file_up input
= gdb_fopen_cloexec (filename
.c_str (), "r");
728 debugfile
= filename
.c_str ();
730 auto_load_debug_printf ("Attempted file \"%s\" %s.",
732 input
!= nullptr ? "exists" : "does not exist");
734 std::string debugfile_holder
;
737 /* Also try the same file in a subdirectory of gdb's data
740 std::vector
<gdb::unique_xmalloc_ptr
<char>> vec
741 = auto_load_expand_dir_vars (auto_load_dir
.c_str ());
743 auto_load_debug_printf
744 ("Searching 'set auto-load scripts-directory' path \"%s\".",
745 auto_load_dir
.c_str ());
747 /* Convert Windows file name from c:/dir/file to /c/dir/file. */
748 if (HAS_DRIVE_SPEC (debugfile
))
749 filename
= (std::string("\\") + debugfile
[0]
750 + STRIP_DRIVE_SPEC (debugfile
));
752 for (const gdb::unique_xmalloc_ptr
<char> &dir
: vec
)
754 /* FILENAME is absolute, so we don't need a "/" here. */
755 debugfile_holder
= dir
.get () + filename
;
756 debugfile
= debugfile_holder
.c_str ();
758 input
= gdb_fopen_cloexec (debugfile
, "r");
760 auto_load_debug_printf ("Attempted file \"%s\" %s.",
764 : "does not exist"));
773 struct auto_load_pspace_info
*pspace_info
;
775 auto_load_debug_printf
776 ("Loading %s script \"%s\" by extension for objfile \"%s\".",
777 ext_lang_name (language
), debugfile
, objfile_name (objfile
));
779 bool is_safe
= file_is_auto_load_safe (debugfile
);
781 /* Add this script to the hash table too so
782 "info auto-load ${lang}-scripts" can print it. */
784 = get_auto_load_pspace_data_for_loading (current_program_space
);
785 maybe_add_script_file (pspace_info
, is_safe
, debugfile
, debugfile
,
788 /* To preserve existing behaviour we don't check for whether the
789 script was already in the table, and always load it.
790 It's highly unlikely that we'd ever load it twice,
791 and these scripts are required to be idempotent under multiple
795 objfile_script_sourcer_func
*sourcer
796 = ext_lang_objfile_script_sourcer (language
);
798 /* We shouldn't get here if support for the language isn't
799 compiled in. And the extension language is required to implement
801 gdb_assert (sourcer
!= NULL
);
802 sourcer (language
, objfile
, input
.get (), debugfile
);
813 /* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
817 auto_load_objfile_script (struct objfile
*objfile
,
818 const struct extension_language_defn
*language
)
820 gdb::unique_xmalloc_ptr
<char> realname
821 = gdb_realpath (objfile_name (objfile
));
823 if (!auto_load_objfile_script_1 (objfile
, realname
.get (), language
))
825 /* For Windows/DOS .exe executables, strip the .exe suffix, so that
826 FOO-gdb.gdb could be used for FOO.exe, and try again. */
828 size_t len
= strlen (realname
.get ());
829 const size_t lexe
= sizeof (".exe") - 1;
831 if (len
> lexe
&& strcasecmp (realname
.get () + len
- lexe
, ".exe") == 0)
834 realname
.get ()[len
] = '\0';
836 auto_load_debug_printf
837 ("auto-load: Stripped .exe suffix, retrying with \"%s\".",
840 auto_load_objfile_script_1 (objfile
, realname
.get (), language
);
845 /* Subroutine of source_section_scripts to simplify it.
846 Load FILE as a script in extension language LANGUAGE.
847 The script is from section SECTION_NAME in OBJFILE at offset OFFSET. */
850 source_script_file (struct auto_load_pspace_info
*pspace_info
,
851 struct objfile
*objfile
,
852 const struct extension_language_defn
*language
,
853 const char *section_name
, unsigned int offset
,
856 objfile_script_sourcer_func
*sourcer
;
858 /* Skip this script if support is not compiled in. */
859 sourcer
= ext_lang_objfile_script_sourcer (language
);
862 /* We don't throw an error, the program is still debuggable. */
863 maybe_print_unsupported_script_warning (pspace_info
, objfile
, language
,
864 section_name
, offset
);
865 /* We *could* still try to open it, but there's no point. */
866 maybe_add_script_file (pspace_info
, 0, file
, NULL
, language
);
870 /* Skip this script if auto-loading it has been disabled. */
871 if (!ext_lang_auto_load_enabled (language
))
873 /* No message is printed, just skip it. */
877 gdb::optional
<open_script
> opened
= find_and_open_script (file
,
882 auto_load_debug_printf
883 ("Loading %s script \"%s\" from section \"%s\" of objfile \"%s\".",
884 ext_lang_name (language
), opened
->full_path
.get (),
885 section_name
, objfile_name (objfile
));
887 if (!file_is_auto_load_safe (opened
->full_path
.get ()))
892 /* If one script isn't found it's not uncommon for more to not be
893 found either. We don't want to print a message for each script,
894 too much noise. Instead, we print the warning once and tell the
895 user how to find the list of scripts that weren't loaded.
896 We don't throw an error, the program is still debuggable.
898 IWBN if complaints.c were more general-purpose. */
900 maybe_print_script_not_found_warning (pspace_info
, objfile
, language
,
901 section_name
, offset
);
905 = maybe_add_script_file (pspace_info
, bool (opened
), file
,
906 (opened
? opened
->full_path
.get (): NULL
),
909 /* If this file is not currently loaded, load it. */
910 if (opened
&& !in_hash_table
)
911 sourcer (language
, objfile
, opened
->stream
.get (),
912 opened
->full_path
.get ());
915 /* Subroutine of source_section_scripts to simplify it.
916 Execute SCRIPT as a script in extension language LANG.
917 The script is from section SECTION_NAME in OBJFILE at offset OFFSET. */
920 execute_script_contents (struct auto_load_pspace_info
*pspace_info
,
921 struct objfile
*objfile
,
922 const struct extension_language_defn
*language
,
923 const char *section_name
, unsigned int offset
,
926 objfile_script_executor_func
*executor
;
927 const char *newline
, *script_text
;
930 /* The first line of the script is the name of the script.
931 It must not contain any kind of space character. */
933 newline
= strchr (script
, '\n');
934 std::string name_holder
;
939 /* Put the name in a buffer and validate it. */
940 name_holder
= std::string (script
, newline
- script
);
941 buf
= name_holder
.c_str ();
942 for (p
= buf
; *p
!= '\0'; ++p
)
947 /* We don't allow nameless scripts, they're not helpful to the user. */
948 if (p
!= buf
&& *p
== '\0')
953 /* We don't throw an error, the program is still debuggable. */
955 Missing/bad script name in entry at offset %u in section %s\n\
957 offset
, section_name
,
958 styled_string (file_name_style
.style (),
959 objfile_name (objfile
)));
962 script_text
= newline
+ 1;
964 /* Skip this script if support is not compiled in. */
965 executor
= ext_lang_objfile_script_executor (language
);
966 if (executor
== NULL
)
968 /* We don't throw an error, the program is still debuggable. */
969 maybe_print_unsupported_script_warning (pspace_info
, objfile
, language
,
970 section_name
, offset
);
971 maybe_add_script_text (pspace_info
, 0, name
, language
);
975 /* Skip this script if auto-loading it has been disabled. */
976 if (!ext_lang_auto_load_enabled (language
))
978 /* No message is printed, just skip it. */
982 auto_load_debug_printf
983 ("Loading %s script \"%s\" from section \"%s\" of objfile \"%s\".",
984 ext_lang_name (language
), name
, section_name
, objfile_name (objfile
));
986 bool is_safe
= file_is_auto_load_safe (objfile_name (objfile
));
989 = maybe_add_script_text (pspace_info
, is_safe
, name
, language
);
991 /* If this file is not currently loaded, load it. */
992 if (is_safe
&& !in_hash_table
)
993 executor (language
, objfile
, name
, script_text
);
996 /* Load scripts specified in OBJFILE.
997 START,END delimit a buffer containing a list of nul-terminated
999 SECTION_NAME is used in error messages.
1001 Scripts specified as file names are found per normal "source -s" command
1002 processing. First the script is looked for in $cwd. If not found there
1003 the source search path is used.
1005 The section contains a list of path names of script files to load or
1006 actual script contents. Each entry is nul-terminated. */
1009 source_section_scripts (struct objfile
*objfile
, const char *section_name
,
1010 const char *start
, const char *end
)
1013 struct auto_load_pspace_info
*pspace_info
;
1015 pspace_info
= get_auto_load_pspace_data_for_loading (current_program_space
);
1017 for (p
= start
; p
< end
; ++p
)
1020 const struct extension_language_defn
*language
;
1021 unsigned int offset
= p
- start
;
1026 case SECTION_SCRIPT_ID_PYTHON_FILE
:
1027 case SECTION_SCRIPT_ID_PYTHON_TEXT
:
1028 language
= get_ext_lang_defn (EXT_LANG_PYTHON
);
1030 case SECTION_SCRIPT_ID_SCHEME_FILE
:
1031 case SECTION_SCRIPT_ID_SCHEME_TEXT
:
1032 language
= get_ext_lang_defn (EXT_LANG_GUILE
);
1035 warning (_("Invalid entry in %s section"), section_name
);
1036 /* We could try various heuristics to find the next valid entry,
1037 but it's safer to just punt. */
1042 while (p
< end
&& *p
!= '\0')
1046 warning (_("Non-nul-terminated entry in %s at offset %u"),
1047 section_name
, offset
);
1048 /* Don't load/execute it. */
1054 case SECTION_SCRIPT_ID_PYTHON_FILE
:
1055 case SECTION_SCRIPT_ID_SCHEME_FILE
:
1058 warning (_("Empty entry in %s at offset %u"),
1059 section_name
, offset
);
1062 source_script_file (pspace_info
, objfile
, language
,
1063 section_name
, offset
, entry
);
1065 case SECTION_SCRIPT_ID_PYTHON_TEXT
:
1066 case SECTION_SCRIPT_ID_SCHEME_TEXT
:
1067 execute_script_contents (pspace_info
, objfile
, language
,
1068 section_name
, offset
, entry
);
1074 /* Load scripts specified in section SECTION_NAME of OBJFILE. */
1077 auto_load_section_scripts (struct objfile
*objfile
, const char *section_name
)
1079 bfd
*abfd
= objfile
->obfd
;
1080 asection
*scripts_sect
;
1081 bfd_byte
*data
= NULL
;
1083 scripts_sect
= bfd_get_section_by_name (abfd
, section_name
);
1084 if (scripts_sect
== NULL
1085 || (bfd_section_flags (scripts_sect
) & SEC_HAS_CONTENTS
) == 0)
1088 if (!bfd_get_full_section_contents (abfd
, scripts_sect
, &data
))
1089 warning (_("Couldn't read %s section of %ps"),
1091 styled_string (file_name_style
.style (),
1092 bfd_get_filename (abfd
)));
1095 gdb::unique_xmalloc_ptr
<bfd_byte
> data_holder (data
);
1097 char *p
= (char *) data
;
1098 source_section_scripts (objfile
, section_name
, p
,
1099 p
+ bfd_section_size (scripts_sect
));
1103 /* Load any auto-loaded scripts for OBJFILE. */
1106 load_auto_scripts_for_objfile (struct objfile
*objfile
)
1108 /* Return immediately if auto-loading has been globally disabled.
1109 This is to handle sequencing of operations during gdb startup.
1110 Also return immediately if OBJFILE was not created from a file
1111 on the local filesystem. */
1112 if (!global_auto_load
1113 || (objfile
->flags
& OBJF_NOT_FILENAME
) != 0
1114 || is_target_filename (objfile
->original_name
))
1117 /* Load any extension language scripts for this objfile.
1118 E.g., foo-gdb.gdb, foo-gdb.py. */
1119 auto_load_ext_lang_scripts_for_objfile (objfile
);
1121 /* Load any scripts mentioned in AUTO_SECTION_NAME (.debug_gdb_scripts). */
1122 auto_load_section_scripts (objfile
, AUTO_SECTION_NAME
);
1125 /* This is a new_objfile observer callback to auto-load scripts.
1127 Two flavors of auto-loaded scripts are supported.
1128 1) based on the path to the objfile
1129 2) from .debug_gdb_scripts section */
1132 auto_load_new_objfile (struct objfile
*objfile
)
1136 /* OBJFILE is NULL when loading a new "main" symbol-file. */
1137 clear_section_scripts ();
1141 load_auto_scripts_for_objfile (objfile
);
1144 /* Collect scripts to be printed in a vec. */
1146 struct collect_matching_scripts_data
1148 collect_matching_scripts_data (std::vector
<loaded_script
*> *scripts_p_
,
1149 const extension_language_defn
*language_
)
1150 : scripts_p (scripts_p_
), language (language_
)
1153 std::vector
<loaded_script
*> *scripts_p
;
1154 const struct extension_language_defn
*language
;
1157 /* Traversal function for htab_traverse.
1158 Collect the entry if it matches the regexp. */
1161 collect_matching_scripts (void **slot
, void *info
)
1163 struct loaded_script
*script
= (struct loaded_script
*) *slot
;
1164 struct collect_matching_scripts_data
*data
1165 = (struct collect_matching_scripts_data
*) info
;
1167 if (script
->language
== data
->language
&& re_exec (script
->name
))
1168 data
->scripts_p
->push_back (script
);
1176 print_script (struct loaded_script
*script
)
1178 struct ui_out
*uiout
= current_uiout
;
1180 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1182 uiout
->field_string ("loaded", script
->loaded
? "Yes" : "No");
1183 uiout
->field_string ("script", script
->name
);
1186 /* If the name isn't the full path, print it too. */
1187 if (script
->full_path
!= NULL
1188 && strcmp (script
->name
, script
->full_path
) != 0)
1190 uiout
->text ("\tfull name: ");
1191 uiout
->field_string ("full_path", script
->full_path
);
1196 /* Helper for info_auto_load_scripts to sort the scripts by name. */
1199 sort_scripts_by_name (loaded_script
*a
, loaded_script
*b
)
1201 return FILENAME_CMP (a
->name
, b
->name
) < 0;
1204 /* Special internal GDB value of auto_load_info_scripts's PATTERN identify
1205 the "info auto-load XXX" command has been executed through the general
1206 "info auto-load" invocation. Extra newline will be printed if needed. */
1207 char auto_load_info_scripts_pattern_nl
[] = "";
1209 /* Subroutine of auto_load_info_scripts to simplify it.
1213 print_scripts (const std::vector
<loaded_script
*> &scripts
)
1215 for (loaded_script
*script
: scripts
)
1216 print_script (script
);
1219 /* Implementation for "info auto-load gdb-scripts"
1220 (and "info auto-load python-scripts"). List scripts in LANGUAGE matching
1221 PATTERN. FROM_TTY is the usual GDB boolean for user interactivity. */
1224 auto_load_info_scripts (const char *pattern
, int from_tty
,
1225 const struct extension_language_defn
*language
)
1227 struct ui_out
*uiout
= current_uiout
;
1228 struct auto_load_pspace_info
*pspace_info
;
1232 pspace_info
= get_auto_load_pspace_data (current_program_space
);
1234 if (pattern
&& *pattern
)
1236 char *re_err
= re_comp (pattern
);
1239 error (_("Invalid regexp: %s"), re_err
);
1246 /* We need to know the number of rows before we build the table.
1247 Plus we want to sort the scripts by name.
1248 So first traverse the hash table collecting the matching scripts. */
1250 std::vector
<loaded_script
*> script_files
, script_texts
;
1252 if (pspace_info
!= NULL
&& pspace_info
->loaded_script_files
!= NULL
)
1254 collect_matching_scripts_data
data (&script_files
, language
);
1256 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
1257 htab_traverse_noresize (pspace_info
->loaded_script_files
.get (),
1258 collect_matching_scripts
, &data
);
1260 std::sort (script_files
.begin (), script_files
.end (),
1261 sort_scripts_by_name
);
1264 if (pspace_info
!= NULL
&& pspace_info
->loaded_script_texts
!= NULL
)
1266 collect_matching_scripts_data
data (&script_texts
, language
);
1268 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
1269 htab_traverse_noresize (pspace_info
->loaded_script_texts
.get (),
1270 collect_matching_scripts
, &data
);
1272 std::sort (script_texts
.begin (), script_texts
.end (),
1273 sort_scripts_by_name
);
1276 int nr_scripts
= script_files
.size () + script_texts
.size ();
1278 /* Table header shifted right by preceding "gdb-scripts: " would not match
1280 if (nr_scripts
> 0 && pattern
== auto_load_info_scripts_pattern_nl
)
1284 ui_out_emit_table
table_emitter (uiout
, 2, nr_scripts
,
1285 "AutoLoadedScriptsTable");
1287 uiout
->table_header (7, ui_left
, "loaded", "Loaded");
1288 uiout
->table_header (70, ui_left
, "script", "Script");
1289 uiout
->table_body ();
1291 print_scripts (script_files
);
1292 print_scripts (script_texts
);
1295 if (nr_scripts
== 0)
1297 if (pattern
&& *pattern
)
1298 uiout
->message ("No auto-load scripts matching %s.\n", pattern
);
1300 uiout
->message ("No auto-load scripts.\n");
1304 /* Wrapper for "info auto-load gdb-scripts". */
1307 info_auto_load_gdb_scripts (const char *pattern
, int from_tty
)
1309 auto_load_info_scripts (pattern
, from_tty
, &extension_language_gdb
);
1312 /* Implement 'info auto-load local-gdbinit'. */
1315 info_auto_load_local_gdbinit (const char *args
, int from_tty
)
1317 if (auto_load_local_gdbinit_pathname
== NULL
)
1318 printf_filtered (_("Local .gdbinit file was not found.\n"));
1319 else if (auto_load_local_gdbinit_loaded
)
1320 printf_filtered (_("Local .gdbinit file \"%ps\" has been loaded.\n"),
1321 styled_string (file_name_style
.style (),
1322 auto_load_local_gdbinit_pathname
));
1324 printf_filtered (_("Local .gdbinit file \"%ps\" has not been loaded.\n"),
1325 styled_string (file_name_style
.style (),
1326 auto_load_local_gdbinit_pathname
));
1329 /* Print an "unsupported script" warning if it has not already been printed.
1330 The script is in language LANGUAGE at offset OFFSET in section SECTION_NAME
1334 maybe_print_unsupported_script_warning
1335 (struct auto_load_pspace_info
*pspace_info
,
1336 struct objfile
*objfile
, const struct extension_language_defn
*language
,
1337 const char *section_name
, unsigned offset
)
1339 if (!pspace_info
->unsupported_script_warning_printed
)
1342 Unsupported auto-load script at offset %u in section %s\n\
1344 Use `info auto-load %s-scripts [REGEXP]' to list them."),
1345 offset
, section_name
,
1346 styled_string (file_name_style
.style (),
1347 objfile_name (objfile
)),
1348 ext_lang_name (language
));
1349 pspace_info
->unsupported_script_warning_printed
= true;
1353 /* Return non-zero if SCRIPT_NOT_FOUND_WARNING_PRINTED of PSPACE_INFO was unset
1354 before calling this function. Always set SCRIPT_NOT_FOUND_WARNING_PRINTED
1358 maybe_print_script_not_found_warning
1359 (struct auto_load_pspace_info
*pspace_info
,
1360 struct objfile
*objfile
, const struct extension_language_defn
*language
,
1361 const char *section_name
, unsigned offset
)
1363 if (!pspace_info
->script_not_found_warning_printed
)
1366 Missing auto-load script at offset %u in section %s\n\
1368 Use `info auto-load %s-scripts [REGEXP]' to list them."),
1369 offset
, section_name
,
1370 styled_string (file_name_style
.style (),
1371 objfile_name (objfile
)),
1372 ext_lang_name (language
));
1373 pspace_info
->script_not_found_warning_printed
= true;
1377 /* The only valid "set auto-load" argument is off|0|no|disable. */
1380 set_auto_load_cmd (const char *args
, int from_tty
)
1382 struct cmd_list_element
*list
;
1385 /* See parse_binary_operation in use by the sub-commands. */
1387 length
= args
? strlen (args
) : 0;
1389 while (length
> 0 && (args
[length
- 1] == ' ' || args
[length
- 1] == '\t'))
1392 if (length
== 0 || (strncmp (args
, "off", length
) != 0
1393 && strncmp (args
, "0", length
) != 0
1394 && strncmp (args
, "no", length
) != 0
1395 && strncmp (args
, "disable", length
) != 0))
1396 error (_("Valid is only global 'set auto-load no'; "
1397 "otherwise check the auto-load sub-commands."));
1399 for (list
= *auto_load_set_cmdlist_get (); list
!= NULL
; list
= list
->next
)
1400 if (list
->var
->type () == var_boolean
)
1402 gdb_assert (list
->type
== set_cmd
);
1403 do_set_command (args
, from_tty
, list
);
1407 /* Initialize "set auto-load " commands prefix and return it. */
1409 struct cmd_list_element
**
1410 auto_load_set_cmdlist_get (void)
1412 static struct cmd_list_element
*retval
;
1415 add_prefix_cmd ("auto-load", class_maintenance
, set_auto_load_cmd
, _("\
1416 Auto-loading specific settings.\n\
1417 Configure various auto-load-specific variables such as\n\
1418 automatic loading of Python scripts."),
1419 &retval
, 1/*allow-unknown*/, &setlist
);
1424 /* Initialize "show auto-load " commands prefix and return it. */
1426 struct cmd_list_element
**
1427 auto_load_show_cmdlist_get (void)
1429 static struct cmd_list_element
*retval
;
1432 add_show_prefix_cmd ("auto-load", class_maintenance
, _("\
1433 Show auto-loading specific settings.\n\
1434 Show configuration of various auto-load-specific variables such as\n\
1435 automatic loading of Python scripts."),
1436 &retval
, 0/*allow-unknown*/, &showlist
);
1441 /* Command "info auto-load" displays whether the various auto-load files have
1442 been loaded. This is reimplementation of cmd_show_list which inserts
1443 newlines at proper places. */
1446 info_auto_load_cmd (const char *args
, int from_tty
)
1448 struct cmd_list_element
*list
;
1449 struct ui_out
*uiout
= current_uiout
;
1451 ui_out_emit_tuple
tuple_emitter (uiout
, "infolist");
1453 for (list
= *auto_load_info_cmdlist_get (); list
!= NULL
; list
= list
->next
)
1455 ui_out_emit_tuple
option_emitter (uiout
, "option");
1457 gdb_assert (!list
->is_prefix ());
1458 gdb_assert (list
->type
== not_set_cmd
);
1460 uiout
->field_string ("name", list
->name
);
1462 cmd_func (list
, auto_load_info_scripts_pattern_nl
, from_tty
);
1466 /* Initialize "info auto-load " commands prefix and return it. */
1468 struct cmd_list_element
**
1469 auto_load_info_cmdlist_get (void)
1471 static struct cmd_list_element
*retval
;
1474 add_prefix_cmd ("auto-load", class_info
, info_auto_load_cmd
, _("\
1475 Print current status of auto-loaded files.\n\
1476 Print whether various files like Python scripts or .gdbinit files have been\n\
1477 found and/or loaded."),
1478 &retval
, 0/*allow-unknown*/, &infolist
);
1483 /* See auto-load.h. */
1485 gdb::observers::token auto_load_new_objfile_observer_token
;
1487 void _initialize_auto_load ();
1489 _initialize_auto_load ()
1491 struct cmd_list_element
*cmd
;
1492 gdb::unique_xmalloc_ptr
<char> scripts_directory_help
, gdb_name_help
,
1493 python_name_help
, guile_name_help
;
1496 gdb::observers::new_objfile
.attach (auto_load_new_objfile
,
1497 auto_load_new_objfile_observer_token
,
1499 add_setshow_boolean_cmd ("gdb-scripts", class_support
,
1500 &auto_load_gdb_scripts
, _("\
1501 Enable or disable auto-loading of canned sequences of commands scripts."), _("\
1502 Show whether auto-loading of canned sequences of commands scripts is enabled."),
1504 If enabled, canned sequences of commands are loaded when the debugger reads\n\
1505 an executable or shared library.\n\
1506 This option has security implications for untrusted inferiors."),
1507 NULL
, show_auto_load_gdb_scripts
,
1508 auto_load_set_cmdlist_get (),
1509 auto_load_show_cmdlist_get ());
1511 add_cmd ("gdb-scripts", class_info
, info_auto_load_gdb_scripts
,
1512 _("Print the list of automatically loaded sequences of commands.\n\
1513 Usage: info auto-load gdb-scripts [REGEXP]"),
1514 auto_load_info_cmdlist_get ());
1516 add_setshow_boolean_cmd ("local-gdbinit", class_support
,
1517 &auto_load_local_gdbinit
, _("\
1518 Enable or disable auto-loading of .gdbinit script in current directory."), _("\
1519 Show whether auto-loading .gdbinit script in current directory is enabled."),
1521 If enabled, canned sequences of commands are loaded when debugger starts\n\
1522 from .gdbinit file in current directory. Such files are deprecated,\n\
1523 use a script associated with inferior executable file instead.\n\
1524 This option has security implications for untrusted inferiors."),
1525 NULL
, show_auto_load_local_gdbinit
,
1526 auto_load_set_cmdlist_get (),
1527 auto_load_show_cmdlist_get ());
1529 add_cmd ("local-gdbinit", class_info
, info_auto_load_local_gdbinit
,
1530 _("Print whether current directory .gdbinit file has been loaded.\n\
1531 Usage: info auto-load local-gdbinit"),
1532 auto_load_info_cmdlist_get ());
1534 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GDB
));
1537 GDB scripts: OBJFILE%s\n"),
1539 python_name_help
= NULL
;
1541 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_PYTHON
));
1544 Python scripts: OBJFILE%s\n"),
1547 guile_name_help
= NULL
;
1549 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GUILE
));
1552 Guile scripts: OBJFILE%s\n"),
1555 scripts_directory_help
1557 Automatically loaded scripts are located in one of the directories listed\n\
1563 This option is ignored for the kinds of scripts \
1564 having 'set auto-load ... off'.\n\
1565 Directories listed here need to be present also \
1566 in the 'set auto-load safe-path'\n\
1568 gdb_name_help
.get (),
1569 python_name_help
.get () ? python_name_help
.get () : "",
1570 guile_name_help
.get () ? guile_name_help
.get () : "");
1572 add_setshow_optional_filename_cmd ("scripts-directory", class_support
,
1573 &auto_load_dir
, _("\
1574 Set the list of directories from which to load auto-loaded scripts."), _("\
1575 Show the list of directories from which to load auto-loaded scripts."),
1576 scripts_directory_help
.get (),
1577 set_auto_load_dir
, show_auto_load_dir
,
1578 auto_load_set_cmdlist_get (),
1579 auto_load_show_cmdlist_get ());
1580 auto_load_safe_path_vec_update ();
1581 add_setshow_optional_filename_cmd ("safe-path", class_support
,
1582 &auto_load_safe_path
, _("\
1583 Set the list of files and directories that are safe for auto-loading."), _("\
1584 Show the list of files and directories that are safe for auto-loading."), _("\
1585 Various files loaded automatically for the 'set auto-load ...' options must\n\
1586 be located in one of the directories listed by this option. Warning will be\n\
1587 printed and file will not be used otherwise.\n\
1588 You can mix both directory and filename entries.\n\
1589 Setting this parameter to an empty list resets it to its default value.\n\
1590 Setting this parameter to '/' (without the quotes) allows any file\n\
1591 for the 'set auto-load ...' options. Each path entry can be also shell\n\
1592 wildcard pattern; '*' does not match directory separator.\n\
1593 This option is ignored for the kinds of files having 'set auto-load ... off'.\n\
1594 This option has security implications for untrusted inferiors."),
1595 set_auto_load_safe_path
,
1596 show_auto_load_safe_path
,
1597 auto_load_set_cmdlist_get (),
1598 auto_load_show_cmdlist_get ());
1599 gdb::observers::gdb_datadir_changed
.attach (auto_load_gdb_datadir_changed
,
1602 cmd
= add_cmd ("add-auto-load-safe-path", class_support
,
1603 add_auto_load_safe_path
,
1604 _("Add entries to the list of directories from which it is safe "
1605 "to auto-load files.\n\
1606 See the commands 'set auto-load safe-path' and 'show auto-load safe-path' to\n\
1607 access the current full list setting."),
1609 set_cmd_completer (cmd
, filename_completer
);
1611 cmd
= add_cmd ("add-auto-load-scripts-directory", class_support
,
1613 _("Add entries to the list of directories from which to load "
1614 "auto-loaded scripts.\n\
1615 See the commands 'set auto-load scripts-directory' and\n\
1616 'show auto-load scripts-directory' to access the current full list setting."),
1618 set_cmd_completer (cmd
, filename_completer
);
1620 add_setshow_boolean_cmd ("auto-load", class_maintenance
,
1621 &debug_auto_load
, _("\
1622 Set auto-load verifications debugging."), _("\
1623 Show auto-load verifications debugging."), _("\
1624 When non-zero, debugging output for files of 'set auto-load ...'\n\
1626 NULL
, show_debug_auto_load
,
1627 &setdebuglist
, &showdebuglist
);