1 /* GDB routines for supporting auto-loaded scripts.
3 Copyright (C) 2012-2021 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 /* Value of the 'set debug auto-load' configuration variable. */
65 static bool debug_auto_load
= false;
67 /* "show" command for the debug_auto_load configuration variable. */
70 show_debug_auto_load (struct ui_file
*file
, int from_tty
,
71 struct cmd_list_element
*c
, const char *value
)
73 fprintf_filtered (file
, _("Debugging output for files "
74 "of 'set auto-load ...' is %s.\n"),
78 /* User-settable option to enable/disable auto-loading of GDB_AUTO_FILE_NAME
80 set auto-load gdb-scripts on|off
81 This is true if we should auto-load associated scripts when an objfile
82 is opened, false otherwise. */
83 static bool auto_load_gdb_scripts
= true;
85 /* "show" command for the auto_load_gdb_scripts configuration variable. */
88 show_auto_load_gdb_scripts (struct ui_file
*file
, int from_tty
,
89 struct cmd_list_element
*c
, const char *value
)
91 fprintf_filtered (file
, _("Auto-loading of canned sequences of commands "
96 /* See auto-load.h. */
99 auto_load_gdb_scripts_enabled (const struct extension_language_defn
*extlang
)
101 return auto_load_gdb_scripts
;
104 /* Internal-use flag to enable/disable auto-loading.
105 This is true if we should auto-load python code when an objfile is opened,
108 Both auto_load_scripts && global_auto_load must be true to enable
111 This flag exists to facilitate deferring auto-loading during start-up
112 until after ./.gdbinit has been read; it may augment the search directories
113 used to find the scripts. */
114 bool global_auto_load
= true;
116 /* Auto-load .gdbinit file from the current directory? */
117 bool auto_load_local_gdbinit
= true;
119 /* Absolute pathname to the current directory .gdbinit, if it exists. */
120 char *auto_load_local_gdbinit_pathname
= NULL
;
122 /* if AUTO_LOAD_LOCAL_GDBINIT_PATHNAME has been loaded. */
123 bool auto_load_local_gdbinit_loaded
= false;
125 /* "show" command for the auto_load_local_gdbinit configuration variable. */
128 show_auto_load_local_gdbinit (struct ui_file
*file
, int from_tty
,
129 struct cmd_list_element
*c
, const char *value
)
131 fprintf_filtered (file
, _("Auto-loading of .gdbinit script from current "
132 "directory is %s.\n"),
136 /* Directory list from which to load auto-loaded scripts. It is not checked
137 for absolute paths but they are strongly recommended. It is initialized by
138 _initialize_auto_load. */
139 static char *auto_load_dir
;
141 /* "set" command for the auto_load_dir configuration variable. */
144 set_auto_load_dir (const char *args
, int from_tty
, struct cmd_list_element
*c
)
146 /* Setting the variable to "" resets it to the compile time defaults. */
147 if (auto_load_dir
[0] == '\0')
149 xfree (auto_load_dir
);
150 auto_load_dir
= xstrdup (AUTO_LOAD_DIR
);
154 /* "show" command for the auto_load_dir configuration variable. */
157 show_auto_load_dir (struct ui_file
*file
, int from_tty
,
158 struct cmd_list_element
*c
, const char *value
)
160 fprintf_filtered (file
, _("List of directories from which to load "
161 "auto-loaded scripts is %s.\n"),
165 /* Directory list safe to hold auto-loaded files. It is not checked for
166 absolute paths but they are strongly recommended. It is initialized by
167 _initialize_auto_load. */
168 static char *auto_load_safe_path
;
170 /* Vector of directory elements of AUTO_LOAD_SAFE_PATH with each one normalized
171 by tilde_expand and possibly each entries has added its gdb_realpath
173 std::vector
<gdb::unique_xmalloc_ptr
<char>> auto_load_safe_path_vec
;
175 /* Expand $datadir and $debugdir in STRING according to the rules of
176 substitute_path_component. */
178 static std::vector
<gdb::unique_xmalloc_ptr
<char>>
179 auto_load_expand_dir_vars (const char *string
)
181 char *s
= xstrdup (string
);
182 substitute_path_component (&s
, "$datadir", gdb_datadir
.c_str ());
183 substitute_path_component (&s
, "$debugdir", debug_file_directory
);
185 if (debug_auto_load
&& strcmp (s
, string
) != 0)
186 fprintf_unfiltered (gdb_stdlog
,
187 _("auto-load: Expanded $-variables to \"%s\".\n"), s
);
189 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
190 = dirnames_to_char_ptr_vec (s
);
196 /* Update auto_load_safe_path_vec from current AUTO_LOAD_SAFE_PATH. */
199 auto_load_safe_path_vec_update (void)
202 fprintf_unfiltered (gdb_stdlog
,
203 _("auto-load: Updating directories of \"%s\".\n"),
204 auto_load_safe_path
);
206 auto_load_safe_path_vec
= auto_load_expand_dir_vars (auto_load_safe_path
);
207 size_t len
= auto_load_safe_path_vec
.size ();
209 /* Apply tilde_expand and gdb_realpath to each AUTO_LOAD_SAFE_PATH_VEC
211 for (size_t i
= 0; i
< len
; i
++)
213 gdb::unique_xmalloc_ptr
<char> &in_vec
= auto_load_safe_path_vec
[i
];
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 /* See auto-load.h. */
467 file_is_auto_load_safe (const char *filename
, const char *debug_fmt
, ...)
469 gdb::unique_xmalloc_ptr
<char> filename_real
;
470 static bool advice_printed
= false;
476 va_start (debug_args
, debug_fmt
);
477 vfprintf_unfiltered (gdb_stdlog
, debug_fmt
, debug_args
);
481 if (filename_is_in_auto_load_safe_path_vec (filename
, &filename_real
))
484 auto_load_safe_path_vec_update ();
485 if (filename_is_in_auto_load_safe_path_vec (filename
, &filename_real
))
488 warning (_("File \"%ps\" auto-loading has been declined by your "
489 "`auto-load safe-path' set to \"%s\"."),
490 styled_string (file_name_style
.style (), filename_real
.get ()),
491 auto_load_safe_path
);
495 /* Find the existing home directory config file. */
497 std::string home_config
= find_gdb_home_config_file (GDBINIT
, &buf
);
498 if (home_config
.empty ())
500 /* The user doesn't have an existing home directory config file,
501 so we should suggest a suitable path for them to use. */
502 std::string config_dir_file
503 = get_standard_config_filename (GDBINIT
);
504 if (!config_dir_file
.empty ())
505 home_config
= config_dir_file
;
508 const char *homedir
= getenv ("HOME");
509 if (homedir
== nullptr)
511 home_config
= (std::string (homedir
) + SLASH_STRING
512 + std::string (GDBINIT
));
516 printf_filtered (_("\
517 To enable execution of this file add\n\
518 \tadd-auto-load-safe-path %s\n\
519 line to your configuration file \"%s\".\n\
520 To completely disable this security protection add\n\
521 \tset auto-load safe-path /\n\
522 line to your configuration file \"%s\".\n\
523 For more information about this security protection see the\n\
524 \"Auto-loading safe path\" section in the GDB manual. E.g., run from the shell:\n\
525 \tinfo \"(gdb)Auto-loading safe path\"\n"),
526 filename_real
.get (),
527 home_config
.c_str (), home_config
.c_str ());
528 advice_printed
= true;
534 /* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
535 the same script. There's no point in loading the script multiple times,
536 and there can be a lot of objfiles and scripts, so we keep track of scripts
539 struct auto_load_pspace_info
541 /* For each program space we keep track of loaded scripts, both when
542 specified as file names and as scripts to be executed directly. */
543 htab_up loaded_script_files
;
544 htab_up loaded_script_texts
;
546 /* Non-zero if we've issued the warning about an auto-load script not being
547 supported. We only want to issue this warning once. */
548 bool unsupported_script_warning_printed
= false;
550 /* Non-zero if we've issued the warning about an auto-load script not being
551 found. We only want to issue this warning once. */
552 bool script_not_found_warning_printed
= false;
555 /* Objects of this type are stored in the loaded_script hash table. */
559 /* Name as provided by the objfile. */
562 /* Full path name or NULL if script wasn't found (or was otherwise
563 inaccessible), or NULL for loaded_script_texts. */
564 const char *full_path
;
566 /* Non-zero if this script has been loaded. */
569 const struct extension_language_defn
*language
;
572 /* Per-program-space data key. */
573 static const struct program_space_key
<struct auto_load_pspace_info
>
574 auto_load_pspace_data
;
576 /* Get the current autoload data. If none is found yet, add it now. This
577 function always returns a valid object. */
579 static struct auto_load_pspace_info
*
580 get_auto_load_pspace_data (struct program_space
*pspace
)
582 struct auto_load_pspace_info
*info
;
584 info
= auto_load_pspace_data
.get (pspace
);
586 info
= auto_load_pspace_data
.emplace (pspace
);
591 /* Hash function for the loaded script hash. */
594 hash_loaded_script_entry (const void *data
)
596 const struct loaded_script
*e
= (const struct loaded_script
*) data
;
598 return htab_hash_string (e
->name
) ^ htab_hash_pointer (e
->language
);
601 /* Equality function for the loaded script hash. */
604 eq_loaded_script_entry (const void *a
, const void *b
)
606 const struct loaded_script
*ea
= (const struct loaded_script
*) a
;
607 const struct loaded_script
*eb
= (const struct loaded_script
*) b
;
609 return strcmp (ea
->name
, eb
->name
) == 0 && ea
->language
== eb
->language
;
612 /* Initialize the table to track loaded scripts.
613 Each entry is hashed by the full path name. */
616 init_loaded_scripts_info (struct auto_load_pspace_info
*pspace_info
)
618 /* Choose 31 as the starting size of the hash table, somewhat arbitrarily.
619 Space for each entry is obtained with one malloc so we can free them
622 pspace_info
->loaded_script_files
.reset
624 hash_loaded_script_entry
,
625 eq_loaded_script_entry
,
627 pspace_info
->loaded_script_texts
.reset
629 hash_loaded_script_entry
,
630 eq_loaded_script_entry
,
633 pspace_info
->unsupported_script_warning_printed
= false;
634 pspace_info
->script_not_found_warning_printed
= false;
637 /* Wrapper on get_auto_load_pspace_data to also allocate the hash table
638 for loading scripts. */
640 struct auto_load_pspace_info
*
641 get_auto_load_pspace_data_for_loading (struct program_space
*pspace
)
643 struct auto_load_pspace_info
*info
;
645 info
= get_auto_load_pspace_data (pspace
);
646 if (info
->loaded_script_files
== NULL
)
647 init_loaded_scripts_info (info
);
652 /* Add script file NAME in LANGUAGE to hash table of PSPACE_INFO.
653 LOADED 1 if the script has been (is going to) be loaded, 0 otherwise
654 (such as if it has not been found).
655 FULL_PATH is NULL if the script wasn't found.
656 The result is true if the script was already in the hash table. */
659 maybe_add_script_file (struct auto_load_pspace_info
*pspace_info
, int loaded
,
660 const char *name
, const char *full_path
,
661 const struct extension_language_defn
*language
)
663 struct htab
*htab
= pspace_info
->loaded_script_files
.get ();
664 struct loaded_script
**slot
, entry
;
668 entry
.language
= language
;
669 slot
= (struct loaded_script
**) htab_find_slot (htab
, &entry
, INSERT
);
670 in_hash_table
= *slot
!= NULL
;
672 /* If this script is not in the hash table, add it. */
678 /* Allocate all space in one chunk so it's easier to free. */
679 *slot
= ((struct loaded_script
*)
680 xmalloc (sizeof (**slot
)
682 + (full_path
!= NULL
? (strlen (full_path
) + 1) : 0)));
683 p
= ((char*) *slot
) + sizeof (**slot
);
686 if (full_path
!= NULL
)
689 strcpy (p
, full_path
);
690 (*slot
)->full_path
= p
;
693 (*slot
)->full_path
= NULL
;
694 (*slot
)->loaded
= loaded
;
695 (*slot
)->language
= language
;
698 return in_hash_table
;
701 /* Add script contents NAME in LANGUAGE to hash table of PSPACE_INFO.
702 LOADED 1 if the script has been (is going to) be loaded, 0 otherwise
703 (such as if it has not been found).
704 The result is true if the script was already in the hash table. */
707 maybe_add_script_text (struct auto_load_pspace_info
*pspace_info
,
708 int loaded
, const char *name
,
709 const struct extension_language_defn
*language
)
711 struct htab
*htab
= pspace_info
->loaded_script_texts
.get ();
712 struct loaded_script
**slot
, entry
;
716 entry
.language
= language
;
717 slot
= (struct loaded_script
**) htab_find_slot (htab
, &entry
, INSERT
);
718 in_hash_table
= *slot
!= NULL
;
720 /* If this script is not in the hash table, add it. */
726 /* Allocate all space in one chunk so it's easier to free. */
727 *slot
= ((struct loaded_script
*)
728 xmalloc (sizeof (**slot
) + strlen (name
) + 1));
729 p
= ((char*) *slot
) + sizeof (**slot
);
732 (*slot
)->full_path
= NULL
;
733 (*slot
)->loaded
= loaded
;
734 (*slot
)->language
= language
;
737 return in_hash_table
;
740 /* Clear the table of loaded section scripts. */
743 clear_section_scripts (void)
745 struct program_space
*pspace
= current_program_space
;
746 struct auto_load_pspace_info
*info
;
748 info
= auto_load_pspace_data
.get (pspace
);
749 if (info
!= NULL
&& info
->loaded_script_files
!= NULL
)
750 auto_load_pspace_data
.clear (pspace
);
753 /* Look for the auto-load script in LANGUAGE associated with OBJFILE where
754 OBJFILE's gdb_realpath is REALNAME and load it. Return 1 if we found any
755 matching script, return 0 otherwise. */
758 auto_load_objfile_script_1 (struct objfile
*objfile
, const char *realname
,
759 const struct extension_language_defn
*language
)
761 const char *debugfile
;
763 const char *suffix
= ext_lang_auto_load_suffix (language
);
765 std::string filename
= std::string (realname
) + suffix
;
767 gdb_file_up input
= gdb_fopen_cloexec (filename
.c_str (), "r");
768 debugfile
= filename
.c_str ();
770 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Attempted file \"%s\" %s.\n"),
771 debugfile
, input
? _("exists") : _("does not exist"));
773 std::string debugfile_holder
;
776 /* Also try the same file in a subdirectory of gdb's data
779 std::vector
<gdb::unique_xmalloc_ptr
<char>> vec
780 = auto_load_expand_dir_vars (auto_load_dir
);
783 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Searching 'set auto-load "
784 "scripts-directory' path \"%s\".\n"),
787 /* Convert Windows file name from c:/dir/file to /c/dir/file. */
788 if (HAS_DRIVE_SPEC (debugfile
))
789 filename
= (std::string("\\") + debugfile
[0]
790 + STRIP_DRIVE_SPEC (debugfile
));
792 for (const gdb::unique_xmalloc_ptr
<char> &dir
: vec
)
794 /* FILENAME is absolute, so we don't need a "/" here. */
795 debugfile_holder
= dir
.get () + filename
;
796 debugfile
= debugfile_holder
.c_str ();
798 input
= gdb_fopen_cloexec (debugfile
, "r");
800 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Attempted file "
803 input
? _("exists") : _("does not exist"));
811 struct auto_load_pspace_info
*pspace_info
;
814 = file_is_auto_load_safe (debugfile
,
815 _("auto-load: Loading %s script \"%s\""
816 " by extension for objfile \"%s\".\n"),
817 ext_lang_name (language
),
818 debugfile
, objfile_name (objfile
));
820 /* Add this script to the hash table too so
821 "info auto-load ${lang}-scripts" can print it. */
823 = get_auto_load_pspace_data_for_loading (current_program_space
);
824 maybe_add_script_file (pspace_info
, is_safe
, debugfile
, debugfile
,
827 /* To preserve existing behaviour we don't check for whether the
828 script was already in the table, and always load it.
829 It's highly unlikely that we'd ever load it twice,
830 and these scripts are required to be idempotent under multiple
834 objfile_script_sourcer_func
*sourcer
835 = ext_lang_objfile_script_sourcer (language
);
837 /* We shouldn't get here if support for the language isn't
838 compiled in. And the extension language is required to implement
840 gdb_assert (sourcer
!= NULL
);
841 sourcer (language
, objfile
, input
.get (), debugfile
);
852 /* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
856 auto_load_objfile_script (struct objfile
*objfile
,
857 const struct extension_language_defn
*language
)
859 gdb::unique_xmalloc_ptr
<char> realname
860 = gdb_realpath (objfile_name (objfile
));
862 if (!auto_load_objfile_script_1 (objfile
, realname
.get (), language
))
864 /* For Windows/DOS .exe executables, strip the .exe suffix, so that
865 FOO-gdb.gdb could be used for FOO.exe, and try again. */
867 size_t len
= strlen (realname
.get ());
868 const size_t lexe
= sizeof (".exe") - 1;
870 if (len
> lexe
&& strcasecmp (realname
.get () + len
- lexe
, ".exe") == 0)
873 realname
.get ()[len
] = '\0';
875 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Stripped .exe suffix, "
876 "retrying with \"%s\".\n"),
878 auto_load_objfile_script_1 (objfile
, realname
.get (), language
);
883 /* Subroutine of source_section_scripts to simplify it.
884 Load FILE as a script in extension language LANGUAGE.
885 The script is from section SECTION_NAME in OBJFILE at offset OFFSET. */
888 source_script_file (struct auto_load_pspace_info
*pspace_info
,
889 struct objfile
*objfile
,
890 const struct extension_language_defn
*language
,
891 const char *section_name
, unsigned int offset
,
895 objfile_script_sourcer_func
*sourcer
;
897 /* Skip this script if support is not compiled in. */
898 sourcer
= ext_lang_objfile_script_sourcer (language
);
901 /* We don't throw an error, the program is still debuggable. */
902 maybe_print_unsupported_script_warning (pspace_info
, objfile
, language
,
903 section_name
, offset
);
904 /* We *could* still try to open it, but there's no point. */
905 maybe_add_script_file (pspace_info
, 0, file
, NULL
, language
);
909 /* Skip this script if auto-loading it has been disabled. */
910 if (!ext_lang_auto_load_enabled (language
))
912 /* No message is printed, just skip it. */
916 gdb::optional
<open_script
> opened
= find_and_open_script (file
,
921 if (!file_is_auto_load_safe (opened
->full_path
.get (),
922 _("auto-load: Loading %s script "
923 "\"%s\" from section \"%s\" of "
924 "objfile \"%s\".\n"),
925 ext_lang_name (language
),
926 opened
->full_path
.get (),
927 section_name
, objfile_name (objfile
)))
932 /* If one script isn't found it's not uncommon for more to not be
933 found either. We don't want to print a message for each script,
934 too much noise. Instead, we print the warning once and tell the
935 user how to find the list of scripts that weren't loaded.
936 We don't throw an error, the program is still debuggable.
938 IWBN if complaints.c were more general-purpose. */
940 maybe_print_script_not_found_warning (pspace_info
, objfile
, language
,
941 section_name
, offset
);
944 in_hash_table
= maybe_add_script_file (pspace_info
, bool (opened
), file
,
946 ? opened
->full_path
.get ()
950 /* If this file is not currently loaded, load it. */
951 if (opened
&& !in_hash_table
)
952 sourcer (language
, objfile
, opened
->stream
.get (),
953 opened
->full_path
.get ());
956 /* Subroutine of source_section_scripts to simplify it.
957 Execute SCRIPT as a script in extension language LANG.
958 The script is from section SECTION_NAME in OBJFILE at offset OFFSET. */
961 execute_script_contents (struct auto_load_pspace_info
*pspace_info
,
962 struct objfile
*objfile
,
963 const struct extension_language_defn
*language
,
964 const char *section_name
, unsigned int offset
,
967 objfile_script_executor_func
*executor
;
968 const char *newline
, *script_text
;
972 /* The first line of the script is the name of the script.
973 It must not contain any kind of space character. */
975 newline
= strchr (script
, '\n');
976 std::string name_holder
;
981 /* Put the name in a buffer and validate it. */
982 name_holder
= std::string (script
, newline
- script
);
983 buf
= name_holder
.c_str ();
984 for (p
= buf
; *p
!= '\0'; ++p
)
989 /* We don't allow nameless scripts, they're not helpful to the user. */
990 if (p
!= buf
&& *p
== '\0')
995 /* We don't throw an error, the program is still debuggable. */
997 Missing/bad script name in entry at offset %u in section %s\n\
999 offset
, section_name
,
1000 styled_string (file_name_style
.style (),
1001 objfile_name (objfile
)));
1004 script_text
= newline
+ 1;
1006 /* Skip this script if support is not compiled in. */
1007 executor
= ext_lang_objfile_script_executor (language
);
1008 if (executor
== NULL
)
1010 /* We don't throw an error, the program is still debuggable. */
1011 maybe_print_unsupported_script_warning (pspace_info
, objfile
, language
,
1012 section_name
, offset
);
1013 maybe_add_script_text (pspace_info
, 0, name
, language
);
1017 /* Skip this script if auto-loading it has been disabled. */
1018 if (!ext_lang_auto_load_enabled (language
))
1020 /* No message is printed, just skip it. */
1025 = file_is_auto_load_safe (objfile_name (objfile
),
1026 _("auto-load: Loading %s script "
1027 "\"%s\" from section \"%s\" of "
1028 "objfile \"%s\".\n"),
1029 ext_lang_name (language
), name
,
1030 section_name
, objfile_name (objfile
));
1032 in_hash_table
= maybe_add_script_text (pspace_info
, is_safe
, name
, language
);
1034 /* If this file is not currently loaded, load it. */
1035 if (is_safe
&& !in_hash_table
)
1036 executor (language
, objfile
, name
, script_text
);
1039 /* Load scripts specified in OBJFILE.
1040 START,END delimit a buffer containing a list of nul-terminated
1042 SECTION_NAME is used in error messages.
1044 Scripts specified as file names are found per normal "source -s" command
1045 processing. First the script is looked for in $cwd. If not found there
1046 the source search path is used.
1048 The section contains a list of path names of script files to load or
1049 actual script contents. Each entry is nul-terminated. */
1052 source_section_scripts (struct objfile
*objfile
, const char *section_name
,
1053 const char *start
, const char *end
)
1056 struct auto_load_pspace_info
*pspace_info
;
1058 pspace_info
= get_auto_load_pspace_data_for_loading (current_program_space
);
1060 for (p
= start
; p
< end
; ++p
)
1063 const struct extension_language_defn
*language
;
1064 unsigned int offset
= p
- start
;
1069 case SECTION_SCRIPT_ID_PYTHON_FILE
:
1070 case SECTION_SCRIPT_ID_PYTHON_TEXT
:
1071 language
= get_ext_lang_defn (EXT_LANG_PYTHON
);
1073 case SECTION_SCRIPT_ID_SCHEME_FILE
:
1074 case SECTION_SCRIPT_ID_SCHEME_TEXT
:
1075 language
= get_ext_lang_defn (EXT_LANG_GUILE
);
1078 warning (_("Invalid entry in %s section"), section_name
);
1079 /* We could try various heuristics to find the next valid entry,
1080 but it's safer to just punt. */
1085 while (p
< end
&& *p
!= '\0')
1089 warning (_("Non-nul-terminated entry in %s at offset %u"),
1090 section_name
, offset
);
1091 /* Don't load/execute it. */
1097 case SECTION_SCRIPT_ID_PYTHON_FILE
:
1098 case SECTION_SCRIPT_ID_SCHEME_FILE
:
1101 warning (_("Empty entry in %s at offset %u"),
1102 section_name
, offset
);
1105 source_script_file (pspace_info
, objfile
, language
,
1106 section_name
, offset
, entry
);
1108 case SECTION_SCRIPT_ID_PYTHON_TEXT
:
1109 case SECTION_SCRIPT_ID_SCHEME_TEXT
:
1110 execute_script_contents (pspace_info
, objfile
, language
,
1111 section_name
, offset
, entry
);
1117 /* Load scripts specified in section SECTION_NAME of OBJFILE. */
1120 auto_load_section_scripts (struct objfile
*objfile
, const char *section_name
)
1122 bfd
*abfd
= objfile
->obfd
;
1123 asection
*scripts_sect
;
1124 bfd_byte
*data
= NULL
;
1126 scripts_sect
= bfd_get_section_by_name (abfd
, section_name
);
1127 if (scripts_sect
== NULL
1128 || (bfd_section_flags (scripts_sect
) & SEC_HAS_CONTENTS
) == 0)
1131 if (!bfd_get_full_section_contents (abfd
, scripts_sect
, &data
))
1132 warning (_("Couldn't read %s section of %ps"),
1134 styled_string (file_name_style
.style (),
1135 bfd_get_filename (abfd
)));
1138 gdb::unique_xmalloc_ptr
<bfd_byte
> data_holder (data
);
1140 char *p
= (char *) data
;
1141 source_section_scripts (objfile
, section_name
, p
,
1142 p
+ bfd_section_size (scripts_sect
));
1146 /* Load any auto-loaded scripts for OBJFILE. */
1149 load_auto_scripts_for_objfile (struct objfile
*objfile
)
1151 /* Return immediately if auto-loading has been globally disabled.
1152 This is to handle sequencing of operations during gdb startup.
1153 Also return immediately if OBJFILE was not created from a file
1154 on the local filesystem. */
1155 if (!global_auto_load
1156 || (objfile
->flags
& OBJF_NOT_FILENAME
) != 0
1157 || is_target_filename (objfile
->original_name
))
1160 /* Load any extension language scripts for this objfile.
1161 E.g., foo-gdb.gdb, foo-gdb.py. */
1162 auto_load_ext_lang_scripts_for_objfile (objfile
);
1164 /* Load any scripts mentioned in AUTO_SECTION_NAME (.debug_gdb_scripts). */
1165 auto_load_section_scripts (objfile
, AUTO_SECTION_NAME
);
1168 /* This is a new_objfile observer callback to auto-load scripts.
1170 Two flavors of auto-loaded scripts are supported.
1171 1) based on the path to the objfile
1172 2) from .debug_gdb_scripts section */
1175 auto_load_new_objfile (struct objfile
*objfile
)
1179 /* OBJFILE is NULL when loading a new "main" symbol-file. */
1180 clear_section_scripts ();
1184 load_auto_scripts_for_objfile (objfile
);
1187 /* Collect scripts to be printed in a vec. */
1189 struct collect_matching_scripts_data
1191 collect_matching_scripts_data (std::vector
<loaded_script
*> *scripts_p_
,
1192 const extension_language_defn
*language_
)
1193 : scripts_p (scripts_p_
), language (language_
)
1196 std::vector
<loaded_script
*> *scripts_p
;
1197 const struct extension_language_defn
*language
;
1200 /* Traversal function for htab_traverse.
1201 Collect the entry if it matches the regexp. */
1204 collect_matching_scripts (void **slot
, void *info
)
1206 struct loaded_script
*script
= (struct loaded_script
*) *slot
;
1207 struct collect_matching_scripts_data
*data
1208 = (struct collect_matching_scripts_data
*) info
;
1210 if (script
->language
== data
->language
&& re_exec (script
->name
))
1211 data
->scripts_p
->push_back (script
);
1219 print_script (struct loaded_script
*script
)
1221 struct ui_out
*uiout
= current_uiout
;
1223 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1225 uiout
->field_string ("loaded", script
->loaded
? "Yes" : "No");
1226 uiout
->field_string ("script", script
->name
);
1229 /* If the name isn't the full path, print it too. */
1230 if (script
->full_path
!= NULL
1231 && strcmp (script
->name
, script
->full_path
) != 0)
1233 uiout
->text ("\tfull name: ");
1234 uiout
->field_string ("full_path", script
->full_path
);
1239 /* Helper for info_auto_load_scripts to sort the scripts by name. */
1242 sort_scripts_by_name (loaded_script
*a
, loaded_script
*b
)
1244 return FILENAME_CMP (a
->name
, b
->name
) < 0;
1247 /* Special internal GDB value of auto_load_info_scripts's PATTERN identify
1248 the "info auto-load XXX" command has been executed through the general
1249 "info auto-load" invocation. Extra newline will be printed if needed. */
1250 char auto_load_info_scripts_pattern_nl
[] = "";
1252 /* Subroutine of auto_load_info_scripts to simplify it.
1256 print_scripts (const std::vector
<loaded_script
*> &scripts
)
1258 for (loaded_script
*script
: scripts
)
1259 print_script (script
);
1262 /* Implementation for "info auto-load gdb-scripts"
1263 (and "info auto-load python-scripts"). List scripts in LANGUAGE matching
1264 PATTERN. FROM_TTY is the usual GDB boolean for user interactivity. */
1267 auto_load_info_scripts (const char *pattern
, int from_tty
,
1268 const struct extension_language_defn
*language
)
1270 struct ui_out
*uiout
= current_uiout
;
1271 struct auto_load_pspace_info
*pspace_info
;
1275 pspace_info
= get_auto_load_pspace_data (current_program_space
);
1277 if (pattern
&& *pattern
)
1279 char *re_err
= re_comp (pattern
);
1282 error (_("Invalid regexp: %s"), re_err
);
1289 /* We need to know the number of rows before we build the table.
1290 Plus we want to sort the scripts by name.
1291 So first traverse the hash table collecting the matching scripts. */
1293 std::vector
<loaded_script
*> script_files
, script_texts
;
1295 if (pspace_info
!= NULL
&& pspace_info
->loaded_script_files
!= NULL
)
1297 collect_matching_scripts_data
data (&script_files
, language
);
1299 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
1300 htab_traverse_noresize (pspace_info
->loaded_script_files
.get (),
1301 collect_matching_scripts
, &data
);
1303 std::sort (script_files
.begin (), script_files
.end (),
1304 sort_scripts_by_name
);
1307 if (pspace_info
!= NULL
&& pspace_info
->loaded_script_texts
!= NULL
)
1309 collect_matching_scripts_data
data (&script_texts
, language
);
1311 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
1312 htab_traverse_noresize (pspace_info
->loaded_script_texts
.get (),
1313 collect_matching_scripts
, &data
);
1315 std::sort (script_texts
.begin (), script_texts
.end (),
1316 sort_scripts_by_name
);
1319 int nr_scripts
= script_files
.size () + script_texts
.size ();
1321 /* Table header shifted right by preceding "gdb-scripts: " would not match
1323 if (nr_scripts
> 0 && pattern
== auto_load_info_scripts_pattern_nl
)
1327 ui_out_emit_table
table_emitter (uiout
, 2, nr_scripts
,
1328 "AutoLoadedScriptsTable");
1330 uiout
->table_header (7, ui_left
, "loaded", "Loaded");
1331 uiout
->table_header (70, ui_left
, "script", "Script");
1332 uiout
->table_body ();
1334 print_scripts (script_files
);
1335 print_scripts (script_texts
);
1338 if (nr_scripts
== 0)
1340 if (pattern
&& *pattern
)
1341 uiout
->message ("No auto-load scripts matching %s.\n", pattern
);
1343 uiout
->message ("No auto-load scripts.\n");
1347 /* Wrapper for "info auto-load gdb-scripts". */
1350 info_auto_load_gdb_scripts (const char *pattern
, int from_tty
)
1352 auto_load_info_scripts (pattern
, from_tty
, &extension_language_gdb
);
1355 /* Implement 'info auto-load local-gdbinit'. */
1358 info_auto_load_local_gdbinit (const char *args
, int from_tty
)
1360 if (auto_load_local_gdbinit_pathname
== NULL
)
1361 printf_filtered (_("Local .gdbinit file was not found.\n"));
1362 else if (auto_load_local_gdbinit_loaded
)
1363 printf_filtered (_("Local .gdbinit file \"%ps\" has been loaded.\n"),
1364 styled_string (file_name_style
.style (),
1365 auto_load_local_gdbinit_pathname
));
1367 printf_filtered (_("Local .gdbinit file \"%ps\" has not been loaded.\n"),
1368 styled_string (file_name_style
.style (),
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
,
1389 styled_string (file_name_style
.style (),
1390 objfile_name (objfile
)),
1391 ext_lang_name (language
));
1392 pspace_info
->unsupported_script_warning_printed
= true;
1396 /* Return non-zero if SCRIPT_NOT_FOUND_WARNING_PRINTED of PSPACE_INFO was unset
1397 before calling this function. Always set SCRIPT_NOT_FOUND_WARNING_PRINTED
1401 maybe_print_script_not_found_warning
1402 (struct auto_load_pspace_info
*pspace_info
,
1403 struct objfile
*objfile
, const struct extension_language_defn
*language
,
1404 const char *section_name
, unsigned offset
)
1406 if (!pspace_info
->script_not_found_warning_printed
)
1409 Missing auto-load script at offset %u in section %s\n\
1411 Use `info auto-load %s-scripts [REGEXP]' to list them."),
1412 offset
, section_name
,
1413 styled_string (file_name_style
.style (),
1414 objfile_name (objfile
)),
1415 ext_lang_name (language
));
1416 pspace_info
->script_not_found_warning_printed
= true;
1420 /* The only valid "set auto-load" argument is off|0|no|disable. */
1423 set_auto_load_cmd (const char *args
, int from_tty
)
1425 struct cmd_list_element
*list
;
1428 /* See parse_binary_operation in use by the sub-commands. */
1430 length
= args
? strlen (args
) : 0;
1432 while (length
> 0 && (args
[length
- 1] == ' ' || args
[length
- 1] == '\t'))
1435 if (length
== 0 || (strncmp (args
, "off", length
) != 0
1436 && strncmp (args
, "0", length
) != 0
1437 && strncmp (args
, "no", length
) != 0
1438 && strncmp (args
, "disable", length
) != 0))
1439 error (_("Valid is only global 'set auto-load no'; "
1440 "otherwise check the auto-load sub-commands."));
1442 for (list
= *auto_load_set_cmdlist_get (); list
!= NULL
; list
= list
->next
)
1443 if (list
->var_type
== var_boolean
)
1445 gdb_assert (list
->type
== set_cmd
);
1446 do_set_command (args
, from_tty
, list
);
1450 /* Initialize "set auto-load " commands prefix and return it. */
1452 struct cmd_list_element
**
1453 auto_load_set_cmdlist_get (void)
1455 static struct cmd_list_element
*retval
;
1458 add_prefix_cmd ("auto-load", class_maintenance
, set_auto_load_cmd
, _("\
1459 Auto-loading specific settings.\n\
1460 Configure various auto-load-specific variables such as\n\
1461 automatic loading of Python scripts."),
1462 &retval
, "set auto-load ",
1463 1/*allow-unknown*/, &setlist
);
1468 /* Initialize "show auto-load " commands prefix and return it. */
1470 struct cmd_list_element
**
1471 auto_load_show_cmdlist_get (void)
1473 static struct cmd_list_element
*retval
;
1476 add_show_prefix_cmd ("auto-load", class_maintenance
, _("\
1477 Show auto-loading specific settings.\n\
1478 Show configuration of various auto-load-specific variables such as\n\
1479 automatic loading of Python scripts."),
1480 &retval
, "show auto-load ",
1481 0/*allow-unknown*/, &showlist
);
1486 /* Command "info auto-load" displays whether the various auto-load files have
1487 been loaded. This is reimplementation of cmd_show_list which inserts
1488 newlines at proper places. */
1491 info_auto_load_cmd (const char *args
, int from_tty
)
1493 struct cmd_list_element
*list
;
1494 struct ui_out
*uiout
= current_uiout
;
1496 ui_out_emit_tuple
tuple_emitter (uiout
, "infolist");
1498 for (list
= *auto_load_info_cmdlist_get (); list
!= NULL
; list
= list
->next
)
1500 ui_out_emit_tuple
option_emitter (uiout
, "option");
1502 gdb_assert (!list
->prefixlist
);
1503 gdb_assert (list
->type
== not_set_cmd
);
1505 uiout
->field_string ("name", list
->name
);
1507 cmd_func (list
, auto_load_info_scripts_pattern_nl
, from_tty
);
1511 /* Initialize "info auto-load " commands prefix and return it. */
1513 struct cmd_list_element
**
1514 auto_load_info_cmdlist_get (void)
1516 static struct cmd_list_element
*retval
;
1519 add_prefix_cmd ("auto-load", class_info
, info_auto_load_cmd
, _("\
1520 Print current status of auto-loaded files.\n\
1521 Print whether various files like Python scripts or .gdbinit files have been\n\
1522 found and/or loaded."),
1523 &retval
, "info auto-load ",
1524 0/*allow-unknown*/, &infolist
);
1529 void _initialize_auto_load ();
1531 _initialize_auto_load ()
1533 struct cmd_list_element
*cmd
;
1534 char *scripts_directory_help
, *gdb_name_help
, *python_name_help
;
1535 char *guile_name_help
;
1538 gdb::observers::new_objfile
.attach (auto_load_new_objfile
);
1540 add_setshow_boolean_cmd ("gdb-scripts", class_support
,
1541 &auto_load_gdb_scripts
, _("\
1542 Enable or disable auto-loading of canned sequences of commands scripts."), _("\
1543 Show whether auto-loading of canned sequences of commands scripts is enabled."),
1545 If enabled, canned sequences of commands are loaded when the debugger reads\n\
1546 an executable or shared library.\n\
1547 This option has security implications for untrusted inferiors."),
1548 NULL
, show_auto_load_gdb_scripts
,
1549 auto_load_set_cmdlist_get (),
1550 auto_load_show_cmdlist_get ());
1552 add_cmd ("gdb-scripts", class_info
, info_auto_load_gdb_scripts
,
1553 _("Print the list of automatically loaded sequences of commands.\n\
1554 Usage: info auto-load gdb-scripts [REGEXP]"),
1555 auto_load_info_cmdlist_get ());
1557 add_setshow_boolean_cmd ("local-gdbinit", class_support
,
1558 &auto_load_local_gdbinit
, _("\
1559 Enable or disable auto-loading of .gdbinit script in current directory."), _("\
1560 Show whether auto-loading .gdbinit script in current directory is enabled."),
1562 If enabled, canned sequences of commands are loaded when debugger starts\n\
1563 from .gdbinit file in current directory. Such files are deprecated,\n\
1564 use a script associated with inferior executable file instead.\n\
1565 This option has security implications for untrusted inferiors."),
1566 NULL
, show_auto_load_local_gdbinit
,
1567 auto_load_set_cmdlist_get (),
1568 auto_load_show_cmdlist_get ());
1570 add_cmd ("local-gdbinit", class_info
, info_auto_load_local_gdbinit
,
1571 _("Print whether current directory .gdbinit file has been loaded.\n\
1572 Usage: info auto-load local-gdbinit"),
1573 auto_load_info_cmdlist_get ());
1575 auto_load_dir
= xstrdup (AUTO_LOAD_DIR
);
1577 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GDB
));
1580 GDB scripts: OBJFILE%s\n"),
1582 python_name_help
= NULL
;
1584 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_PYTHON
));
1587 Python scripts: OBJFILE%s\n"),
1590 guile_name_help
= NULL
;
1592 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GUILE
));
1595 Guile scripts: OBJFILE%s\n"),
1598 scripts_directory_help
1600 Automatically loaded scripts are located in one of the directories listed\n\
1606 This option is ignored for the kinds of scripts \
1607 having 'set auto-load ... off'.\n\
1608 Directories listed here need to be present also \
1609 in the 'set auto-load safe-path'\n\
1612 python_name_help
? python_name_help
: "",
1613 guile_name_help
? guile_name_help
: "");
1615 add_setshow_optional_filename_cmd ("scripts-directory", class_support
,
1616 &auto_load_dir
, _("\
1617 Set the list of directories from which to load auto-loaded scripts."), _("\
1618 Show the list of directories from which to load auto-loaded scripts."),
1619 scripts_directory_help
,
1620 set_auto_load_dir
, show_auto_load_dir
,
1621 auto_load_set_cmdlist_get (),
1622 auto_load_show_cmdlist_get ());
1623 xfree (scripts_directory_help
);
1624 xfree (python_name_help
);
1625 xfree (gdb_name_help
);
1626 xfree (guile_name_help
);
1628 auto_load_safe_path
= xstrdup (AUTO_LOAD_SAFE_PATH
);
1629 auto_load_safe_path_vec_update ();
1630 add_setshow_optional_filename_cmd ("safe-path", class_support
,
1631 &auto_load_safe_path
, _("\
1632 Set the list of files and directories that are safe for auto-loading."), _("\
1633 Show the list of files and directories that are safe for auto-loading."), _("\
1634 Various files loaded automatically for the 'set auto-load ...' options must\n\
1635 be located in one of the directories listed by this option. Warning will be\n\
1636 printed and file will not be used otherwise.\n\
1637 You can mix both directory and filename entries.\n\
1638 Setting this parameter to an empty list resets it to its default value.\n\
1639 Setting this parameter to '/' (without the quotes) allows any file\n\
1640 for the 'set auto-load ...' options. Each path entry can be also shell\n\
1641 wildcard pattern; '*' does not match directory separator.\n\
1642 This option is ignored for the kinds of files having 'set auto-load ... off'.\n\
1643 This option has security implications for untrusted inferiors."),
1644 set_auto_load_safe_path
,
1645 show_auto_load_safe_path
,
1646 auto_load_set_cmdlist_get (),
1647 auto_load_show_cmdlist_get ());
1648 gdb::observers::gdb_datadir_changed
.attach (auto_load_gdb_datadir_changed
);
1650 cmd
= add_cmd ("add-auto-load-safe-path", class_support
,
1651 add_auto_load_safe_path
,
1652 _("Add entries to the list of directories from which it is safe "
1653 "to auto-load files.\n\
1654 See the commands 'set auto-load safe-path' and 'show auto-load safe-path' to\n\
1655 access the current full list setting."),
1657 set_cmd_completer (cmd
, filename_completer
);
1659 cmd
= add_cmd ("add-auto-load-scripts-directory", class_support
,
1661 _("Add entries to the list of directories from which to load "
1662 "auto-loaded scripts.\n\
1663 See the commands 'set auto-load scripts-directory' and\n\
1664 'show auto-load scripts-directory' to access the current full list setting."),
1666 set_cmd_completer (cmd
, filename_completer
);
1668 add_setshow_boolean_cmd ("auto-load", class_maintenance
,
1669 &debug_auto_load
, _("\
1670 Set auto-load verifications debugging."), _("\
1671 Show auto-load verifications debugging."), _("\
1672 When non-zero, debugging output for files of 'set auto-load ...'\n\
1674 NULL
, show_debug_auto_load
,
1675 &setdebuglist
, &showdebuglist
);