1 /* GDB routines for supporting auto-loaded scripts.
3 Copyright (C) 2012-2018 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "auto-load.h"
23 #include "progspace.h"
24 #include "gdb_regex.h"
26 #include "filenames.h"
30 #include "cli/cli-script.h"
32 #include "cli/cli-cmds.h"
33 #include "cli/cli-decode.h"
34 #include "cli/cli-setshow.h"
35 #include "readline/tilde.h"
36 #include "completer.h"
39 #include "filestuff.h"
40 #include "extension.h"
41 #include "gdb/section-scripts.h"
44 /* The section to look in for auto-loaded scripts (in file formats that
46 Each entry in this section is a record that begins with a leading byte
47 identifying the record type.
48 At the moment we only support one record type: A leading byte of 1,
49 followed by the path of a python script to load. */
50 #define AUTO_SECTION_NAME ".debug_gdb_scripts"
52 static void maybe_print_unsupported_script_warning
53 (struct auto_load_pspace_info
*, struct objfile
*objfile
,
54 const struct extension_language_defn
*language
,
55 const char *section_name
, unsigned offset
);
57 static void maybe_print_script_not_found_warning
58 (struct auto_load_pspace_info
*, struct objfile
*objfile
,
59 const struct extension_language_defn
*language
,
60 const char *section_name
, unsigned offset
);
62 /* Value of the 'set debug auto-load' configuration variable. */
63 static int debug_auto_load
= 0;
65 /* "show" command for the debug_auto_load configuration variable. */
68 show_debug_auto_load (struct ui_file
*file
, int from_tty
,
69 struct cmd_list_element
*c
, const char *value
)
71 fprintf_filtered (file
, _("Debugging output for files "
72 "of 'set auto-load ...' is %s.\n"),
76 /* User-settable option to enable/disable auto-loading of GDB_AUTO_FILE_NAME
78 set auto-load gdb-scripts on|off
79 This is true if we should auto-load associated scripts when an objfile
80 is opened, false otherwise. */
81 static int auto_load_gdb_scripts
= 1;
83 /* "show" command for the auto_load_gdb_scripts configuration variable. */
86 show_auto_load_gdb_scripts (struct ui_file
*file
, int from_tty
,
87 struct cmd_list_element
*c
, const char *value
)
89 fprintf_filtered (file
, _("Auto-loading of canned sequences of commands "
94 /* Return non-zero if auto-loading gdb scripts is enabled. */
97 auto_load_gdb_scripts_enabled (const struct extension_language_defn
*extlang
)
99 return auto_load_gdb_scripts
;
102 /* Internal-use flag to enable/disable auto-loading.
103 This is true if we should auto-load python code when an objfile is opened,
106 Both auto_load_scripts && global_auto_load must be true to enable
109 This flag exists to facilitate deferring auto-loading during start-up
110 until after ./.gdbinit has been read; it may augment the search directories
111 used to find the scripts. */
112 int global_auto_load
= 1;
114 /* Auto-load .gdbinit file from the current directory? */
115 int auto_load_local_gdbinit
= 1;
117 /* Absolute pathname to the current directory .gdbinit, if it exists. */
118 char *auto_load_local_gdbinit_pathname
= NULL
;
120 /* Boolean value if AUTO_LOAD_LOCAL_GDBINIT_PATHNAME has been loaded. */
121 int auto_load_local_gdbinit_loaded
= 0;
123 /* "show" command for the auto_load_local_gdbinit configuration variable. */
126 show_auto_load_local_gdbinit (struct ui_file
*file
, int from_tty
,
127 struct cmd_list_element
*c
, const char *value
)
129 fprintf_filtered (file
, _("Auto-loading of .gdbinit script from current "
130 "directory is %s.\n"),
134 /* Directory list from which to load auto-loaded scripts. It is not checked
135 for absolute paths but they are strongly recommended. It is initialized by
136 _initialize_auto_load. */
137 static char *auto_load_dir
;
139 /* "set" command for the auto_load_dir configuration variable. */
142 set_auto_load_dir (const char *args
, int from_tty
, struct cmd_list_element
*c
)
144 /* Setting the variable to "" resets it to the compile time defaults. */
145 if (auto_load_dir
[0] == '\0')
147 xfree (auto_load_dir
);
148 auto_load_dir
= xstrdup (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 char *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 VEC (char_ptr
) *auto_load_safe_path_vec
;
173 /* Expand $datadir and $debugdir in STRING according to the rules of
174 substitute_path_component. Return vector from dirnames_to_char_ptr_vec,
175 this vector must be freed by free_char_ptr_vec by the caller. */
177 static VEC (char_ptr
) *
178 auto_load_expand_dir_vars (const char *string
)
180 VEC (char_ptr
) *dir_vec
;
183 s
= xstrdup (string
);
184 substitute_path_component (&s
, "$datadir", gdb_datadir
);
185 substitute_path_component (&s
, "$debugdir", debug_file_directory
);
187 if (debug_auto_load
&& strcmp (s
, string
) != 0)
188 fprintf_unfiltered (gdb_stdlog
,
189 _("auto-load: Expanded $-variables to \"%s\".\n"), s
);
191 dir_vec
= dirnames_to_char_ptr_vec (s
);
197 /* Update auto_load_safe_path_vec from current AUTO_LOAD_SAFE_PATH. */
200 auto_load_safe_path_vec_update (void)
206 fprintf_unfiltered (gdb_stdlog
,
207 _("auto-load: Updating directories of \"%s\".\n"),
208 auto_load_safe_path
);
210 free_char_ptr_vec (auto_load_safe_path_vec
);
212 auto_load_safe_path_vec
= auto_load_expand_dir_vars (auto_load_safe_path
);
213 len
= VEC_length (char_ptr
, auto_load_safe_path_vec
);
215 /* Apply tilde_expand and gdb_realpath to each AUTO_LOAD_SAFE_PATH_VEC
217 for (ix
= 0; ix
< len
; ix
++)
219 char *dir
= VEC_index (char_ptr
, auto_load_safe_path_vec
, ix
);
220 char *expanded
= tilde_expand (dir
);
221 gdb::unique_xmalloc_ptr
<char> real_path
= gdb_realpath (expanded
);
223 /* Ensure the current entry is at least tilde_expand-ed. */
224 VEC_replace (char_ptr
, auto_load_safe_path_vec
, ix
, expanded
);
228 if (strcmp (expanded
, dir
) == 0)
229 fprintf_unfiltered (gdb_stdlog
,
230 _("auto-load: Using directory \"%s\".\n"),
233 fprintf_unfiltered (gdb_stdlog
,
234 _("auto-load: Resolved directory \"%s\" "
240 /* If gdb_realpath returns a different content, append it. */
241 if (strcmp (real_path
.get (), expanded
) != 0)
244 fprintf_unfiltered (gdb_stdlog
,
245 _("auto-load: And canonicalized as \"%s\".\n"),
248 VEC_safe_push (char_ptr
, auto_load_safe_path_vec
,
249 real_path
.release ());
254 /* Variable gdb_datadir has been set. Update content depending on $datadir. */
257 auto_load_gdb_datadir_changed (void)
259 auto_load_safe_path_vec_update ();
262 /* "set" command for the auto_load_safe_path configuration variable. */
265 set_auto_load_safe_path (const char *args
,
266 int from_tty
, struct cmd_list_element
*c
)
268 /* Setting the variable to "" resets it to the compile time defaults. */
269 if (auto_load_safe_path
[0] == '\0')
271 xfree (auto_load_safe_path
);
272 auto_load_safe_path
= xstrdup (AUTO_LOAD_SAFE_PATH
);
275 auto_load_safe_path_vec_update ();
278 /* "show" command for the auto_load_safe_path configuration variable. */
281 show_auto_load_safe_path (struct ui_file
*file
, int from_tty
,
282 struct cmd_list_element
*c
, const char *value
)
286 /* Check if user has entered either "/" or for example ":".
287 But while more complicate content like ":/foo" would still also
288 permit any location do not hide those. */
290 for (cs
= value
; *cs
&& (*cs
== DIRNAME_SEPARATOR
|| IS_DIR_SEPARATOR (*cs
));
293 fprintf_filtered (file
, _("Auto-load files are safe to load from any "
296 fprintf_filtered (file
, _("List of directories from which it is safe to "
297 "auto-load files is %s.\n"),
301 /* "add-auto-load-safe-path" command for the auto_load_safe_path configuration
305 add_auto_load_safe_path (const char *args
, int from_tty
)
309 if (args
== NULL
|| *args
== 0)
311 Directory argument required.\n\
312 Use 'set auto-load safe-path /' for disabling the auto-load safe-path security.\
315 s
= xstrprintf ("%s%c%s", auto_load_safe_path
, DIRNAME_SEPARATOR
, args
);
316 xfree (auto_load_safe_path
);
317 auto_load_safe_path
= s
;
319 auto_load_safe_path_vec_update ();
322 /* "add-auto-load-scripts-directory" command for the auto_load_dir configuration
326 add_auto_load_dir (const char *args
, int from_tty
)
330 if (args
== NULL
|| *args
== 0)
331 error (_("Directory argument required."));
333 s
= xstrprintf ("%s%c%s", auto_load_dir
, DIRNAME_SEPARATOR
, args
);
334 xfree (auto_load_dir
);
338 /* Implementation for filename_is_in_pattern overwriting the caller's FILENAME
342 filename_is_in_pattern_1 (char *filename
, char *pattern
)
344 size_t pattern_len
= strlen (pattern
);
345 size_t filename_len
= strlen (filename
);
348 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Matching file \"%s\" "
349 "to pattern \"%s\"\n"),
352 /* Trim trailing slashes ("/") from PATTERN. Even for "d:\" paths as
353 trailing slashes are trimmed also from FILENAME it still matches
355 while (pattern_len
&& IS_DIR_SEPARATOR (pattern
[pattern_len
- 1]))
357 pattern
[pattern_len
] = '\0';
359 /* Ensure auto_load_safe_path "/" matches any FILENAME. On MS-Windows
360 platform FILENAME even after gdb_realpath does not have to start with
361 IS_DIR_SEPARATOR character, such as the 'C:\x.exe' filename. */
362 if (pattern_len
== 0)
365 fprintf_unfiltered (gdb_stdlog
,
366 _("auto-load: Matched - empty pattern\n"));
372 /* Trim trailing slashes ("/"). PATTERN also has slashes trimmed the
373 same way so they will match. */
374 while (filename_len
&& IS_DIR_SEPARATOR (filename
[filename_len
- 1]))
376 filename
[filename_len
] = '\0';
377 if (filename_len
== 0)
380 fprintf_unfiltered (gdb_stdlog
,
381 _("auto-load: Not matched - pattern \"%s\".\n"),
386 if (gdb_filename_fnmatch (pattern
, filename
, FNM_FILE_NAME
| FNM_NOESCAPE
)
390 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Matched - file "
391 "\"%s\" to pattern \"%s\".\n"),
396 /* Trim trailing FILENAME component. */
397 while (filename_len
> 0 && !IS_DIR_SEPARATOR (filename
[filename_len
- 1]))
402 /* Return 1 if FILENAME matches PATTERN or if FILENAME resides in
403 a subdirectory of a directory that matches PATTERN. Return 0 otherwise.
404 gdb_realpath normalization is never done here. */
406 static ATTRIBUTE_PURE
int
407 filename_is_in_pattern (const char *filename
, const char *pattern
)
409 char *filename_copy
, *pattern_copy
;
411 filename_copy
= (char *) alloca (strlen (filename
) + 1);
412 strcpy (filename_copy
, filename
);
413 pattern_copy
= (char *) alloca (strlen (pattern
) + 1);
414 strcpy (pattern_copy
, pattern
);
416 return filename_is_in_pattern_1 (filename_copy
, pattern_copy
);
419 /* Return 1 if FILENAME belongs to one of directory components of
420 AUTO_LOAD_SAFE_PATH_VEC. Return 0 otherwise.
421 auto_load_safe_path_vec_update is never called.
422 *FILENAME_REALP may be updated by gdb_realpath of FILENAME. */
425 filename_is_in_auto_load_safe_path_vec (const char *filename
,
426 gdb::unique_xmalloc_ptr
<char> *filename_realp
)
431 for (ix
= 0; VEC_iterate (char_ptr
, auto_load_safe_path_vec
, ix
, pattern
);
433 if (*filename_realp
== NULL
&& filename_is_in_pattern (filename
, pattern
))
438 if (*filename_realp
== NULL
)
440 *filename_realp
= gdb_realpath (filename
);
441 if (debug_auto_load
&& strcmp (filename_realp
->get (), filename
) != 0)
442 fprintf_unfiltered (gdb_stdlog
,
443 _("auto-load: Resolved "
444 "file \"%s\" as \"%s\".\n"),
445 filename
, filename_realp
->get ());
448 if (strcmp (filename_realp
->get (), filename
) != 0)
450 VEC_iterate (char_ptr
, auto_load_safe_path_vec
, ix
, pattern
); ++ix
)
451 if (filename_is_in_pattern (filename_realp
->get (), pattern
))
458 fprintf_unfiltered (gdb_stdlog
, _("auto-load: File \"%s\" matches "
459 "directory \"%s\".\n"),
467 /* Return 1 if FILENAME is located in one of the directories of
468 AUTO_LOAD_SAFE_PATH. Otherwise call warning and return 0. FILENAME does
469 not have to be an absolute path.
471 Existence of FILENAME is not checked. Function will still give a warning
472 even if the caller would quietly skip non-existing file in unsafe
476 file_is_auto_load_safe (const char *filename
, const char *debug_fmt
, ...)
478 gdb::unique_xmalloc_ptr
<char> filename_real
;
479 static int advice_printed
= 0;
485 va_start (debug_args
, debug_fmt
);
486 vfprintf_unfiltered (gdb_stdlog
, debug_fmt
, debug_args
);
490 if (filename_is_in_auto_load_safe_path_vec (filename
, &filename_real
))
493 auto_load_safe_path_vec_update ();
494 if (filename_is_in_auto_load_safe_path_vec (filename
, &filename_real
))
497 warning (_("File \"%s\" auto-loading has been declined by your "
498 "`auto-load safe-path' set to \"%s\"."),
499 filename_real
.get (), auto_load_safe_path
);
503 const char *homedir
= getenv ("HOME");
507 std::string homeinit
= string_printf ("%s/%s", homedir
, gdbinit
);
509 printf_filtered (_("\
510 To enable execution of this file add\n\
511 \tadd-auto-load-safe-path %s\n\
512 line to your configuration file \"%s\".\n\
513 To completely disable this security protection add\n\
514 \tset auto-load safe-path /\n\
515 line to your configuration file \"%s\".\n\
516 For more information about this security protection see the\n\
517 \"Auto-loading safe path\" section in the GDB manual. E.g., run from the shell:\n\
518 \tinfo \"(gdb)Auto-loading safe path\"\n"),
519 filename_real
.get (),
520 homeinit
.c_str (), homeinit
.c_str ());
527 /* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
528 the same script. There's no point in loading the script multiple times,
529 and there can be a lot of objfiles and scripts, so we keep track of scripts
532 struct auto_load_pspace_info
534 /* For each program space we keep track of loaded scripts, both when
535 specified as file names and as scripts to be executed directly. */
536 struct htab
*loaded_script_files
;
537 struct htab
*loaded_script_texts
;
539 /* Non-zero if we've issued the warning about an auto-load script not being
540 supported. We only want to issue this warning once. */
541 int unsupported_script_warning_printed
;
543 /* Non-zero if we've issued the warning about an auto-load script not being
544 found. We only want to issue this warning once. */
545 int script_not_found_warning_printed
;
548 /* Objects of this type are stored in the loaded_script hash table. */
552 /* Name as provided by the objfile. */
555 /* Full path name or NULL if script wasn't found (or was otherwise
556 inaccessible), or NULL for loaded_script_texts. */
557 const char *full_path
;
559 /* Non-zero if this script has been loaded. */
562 const struct extension_language_defn
*language
;
565 /* Per-program-space data key. */
566 static const struct program_space_data
*auto_load_pspace_data
;
569 auto_load_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
571 struct auto_load_pspace_info
*info
= (struct auto_load_pspace_info
*) arg
;
573 if (info
->loaded_script_files
)
574 htab_delete (info
->loaded_script_files
);
575 if (info
->loaded_script_texts
)
576 htab_delete (info
->loaded_script_texts
);
580 /* Get the current autoload data. If none is found yet, add it now. This
581 function always returns a valid object. */
583 static struct auto_load_pspace_info
*
584 get_auto_load_pspace_data (struct program_space
*pspace
)
586 struct auto_load_pspace_info
*info
;
588 info
= ((struct auto_load_pspace_info
*)
589 program_space_data (pspace
, auto_load_pspace_data
));
592 info
= XCNEW (struct auto_load_pspace_info
);
593 set_program_space_data (pspace
, auto_load_pspace_data
, info
);
599 /* Hash function for the loaded script hash. */
602 hash_loaded_script_entry (const void *data
)
604 const struct loaded_script
*e
= (const struct loaded_script
*) data
;
606 return htab_hash_string (e
->name
) ^ htab_hash_pointer (e
->language
);
609 /* Equality function for the loaded script hash. */
612 eq_loaded_script_entry (const void *a
, const void *b
)
614 const struct loaded_script
*ea
= (const struct loaded_script
*) a
;
615 const struct loaded_script
*eb
= (const struct loaded_script
*) b
;
617 return strcmp (ea
->name
, eb
->name
) == 0 && ea
->language
== eb
->language
;
620 /* Initialize the table to track loaded scripts.
621 Each entry is hashed by the full path name. */
624 init_loaded_scripts_info (struct auto_load_pspace_info
*pspace_info
)
626 /* Choose 31 as the starting size of the hash table, somewhat arbitrarily.
627 Space for each entry is obtained with one malloc so we can free them
630 pspace_info
->loaded_script_files
= htab_create (31,
631 hash_loaded_script_entry
,
632 eq_loaded_script_entry
,
634 pspace_info
->loaded_script_texts
= htab_create (31,
635 hash_loaded_script_entry
,
636 eq_loaded_script_entry
,
639 pspace_info
->unsupported_script_warning_printed
= FALSE
;
640 pspace_info
->script_not_found_warning_printed
= FALSE
;
643 /* Wrapper on get_auto_load_pspace_data to also allocate the hash table
644 for loading scripts. */
646 struct auto_load_pspace_info
*
647 get_auto_load_pspace_data_for_loading (struct program_space
*pspace
)
649 struct auto_load_pspace_info
*info
;
651 info
= get_auto_load_pspace_data (pspace
);
652 if (info
->loaded_script_files
== NULL
)
653 init_loaded_scripts_info (info
);
658 /* Add script file NAME in LANGUAGE to hash table of PSPACE_INFO.
659 LOADED 1 if the script has been (is going to) be loaded, 0 otherwise
660 (such as if it has not been found).
661 FULL_PATH is NULL if the script wasn't found.
662 The result is true if the script was already in the hash table. */
665 maybe_add_script_file (struct auto_load_pspace_info
*pspace_info
, int loaded
,
666 const char *name
, const char *full_path
,
667 const struct extension_language_defn
*language
)
669 struct htab
*htab
= pspace_info
->loaded_script_files
;
670 struct loaded_script
**slot
, entry
;
674 entry
.language
= language
;
675 slot
= (struct loaded_script
**) htab_find_slot (htab
, &entry
, INSERT
);
676 in_hash_table
= *slot
!= NULL
;
678 /* If this script is not in the hash table, add it. */
684 /* Allocate all space in one chunk so it's easier to free. */
685 *slot
= ((struct loaded_script
*)
686 xmalloc (sizeof (**slot
)
688 + (full_path
!= NULL
? (strlen (full_path
) + 1) : 0)));
689 p
= ((char*) *slot
) + sizeof (**slot
);
692 if (full_path
!= NULL
)
695 strcpy (p
, full_path
);
696 (*slot
)->full_path
= p
;
699 (*slot
)->full_path
= NULL
;
700 (*slot
)->loaded
= loaded
;
701 (*slot
)->language
= language
;
704 return in_hash_table
;
707 /* Add script contents NAME in LANGUAGE to hash table of PSPACE_INFO.
708 LOADED 1 if the script has been (is going to) be loaded, 0 otherwise
709 (such as if it has not been found).
710 The result is true if the script was already in the hash table. */
713 maybe_add_script_text (struct auto_load_pspace_info
*pspace_info
,
714 int loaded
, const char *name
,
715 const struct extension_language_defn
*language
)
717 struct htab
*htab
= pspace_info
->loaded_script_texts
;
718 struct loaded_script
**slot
, entry
;
722 entry
.language
= language
;
723 slot
= (struct loaded_script
**) htab_find_slot (htab
, &entry
, INSERT
);
724 in_hash_table
= *slot
!= NULL
;
726 /* If this script is not in the hash table, add it. */
732 /* Allocate all space in one chunk so it's easier to free. */
733 *slot
= ((struct loaded_script
*)
734 xmalloc (sizeof (**slot
) + strlen (name
) + 1));
735 p
= ((char*) *slot
) + sizeof (**slot
);
738 (*slot
)->full_path
= NULL
;
739 (*slot
)->loaded
= loaded
;
740 (*slot
)->language
= language
;
743 return in_hash_table
;
746 /* Clear the table of loaded section scripts. */
749 clear_section_scripts (void)
751 struct program_space
*pspace
= current_program_space
;
752 struct auto_load_pspace_info
*info
;
754 info
= ((struct auto_load_pspace_info
*)
755 program_space_data (pspace
, auto_load_pspace_data
));
756 if (info
!= NULL
&& info
->loaded_script_files
!= NULL
)
758 htab_delete (info
->loaded_script_files
);
759 htab_delete (info
->loaded_script_texts
);
760 info
->loaded_script_files
= NULL
;
761 info
->loaded_script_texts
= NULL
;
762 info
->unsupported_script_warning_printed
= FALSE
;
763 info
->script_not_found_warning_printed
= FALSE
;
767 /* Look for the auto-load script in LANGUAGE associated with OBJFILE where
768 OBJFILE's gdb_realpath is REALNAME and load it. Return 1 if we found any
769 matching script, return 0 otherwise. */
772 auto_load_objfile_script_1 (struct objfile
*objfile
, const char *realname
,
773 const struct extension_language_defn
*language
)
775 char *filename
, *debugfile
;
777 struct cleanup
*cleanups
;
778 const char *suffix
= ext_lang_auto_load_suffix (language
);
780 len
= strlen (realname
);
781 filename
= (char *) xmalloc (len
+ strlen (suffix
) + 1);
782 memcpy (filename
, realname
, len
);
783 strcpy (filename
+ len
, suffix
);
785 cleanups
= make_cleanup (xfree
, filename
);
787 gdb_file_up input
= gdb_fopen_cloexec (filename
, "r");
788 debugfile
= filename
;
790 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Attempted file \"%s\" %s.\n"),
791 debugfile
, input
? _("exists") : _("does not exist"));
799 /* Also try the same file in a subdirectory of gdb's data
802 vec
= auto_load_expand_dir_vars (auto_load_dir
);
803 make_cleanup_free_char_ptr_vec (vec
);
806 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Searching 'set auto-load "
807 "scripts-directory' path \"%s\".\n"),
810 for (ix
= 0; VEC_iterate (char_ptr
, vec
, ix
, dir
); ++ix
)
812 debugfile
= (char *) xmalloc (strlen (dir
) + strlen (filename
) + 1);
813 strcpy (debugfile
, dir
);
815 /* FILENAME is absolute, so we don't need a "/" here. */
816 strcat (debugfile
, filename
);
818 make_cleanup (xfree
, debugfile
);
819 input
= gdb_fopen_cloexec (debugfile
, "r");
821 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Attempted file "
824 input
? _("exists") : _("does not exist"));
833 struct auto_load_pspace_info
*pspace_info
;
836 = file_is_auto_load_safe (debugfile
,
837 _("auto-load: Loading %s script \"%s\""
838 " by extension for objfile \"%s\".\n"),
839 ext_lang_name (language
),
840 debugfile
, objfile_name (objfile
));
842 /* Add this script to the hash table too so
843 "info auto-load ${lang}-scripts" can print it. */
845 = get_auto_load_pspace_data_for_loading (current_program_space
);
846 maybe_add_script_file (pspace_info
, is_safe
, debugfile
, debugfile
,
849 /* To preserve existing behaviour we don't check for whether the
850 script was already in the table, and always load it.
851 It's highly unlikely that we'd ever load it twice,
852 and these scripts are required to be idempotent under multiple
856 objfile_script_sourcer_func
*sourcer
857 = ext_lang_objfile_script_sourcer (language
);
859 /* We shouldn't get here if support for the language isn't
860 compiled in. And the extension language is required to implement
862 gdb_assert (sourcer
!= NULL
);
863 sourcer (language
, objfile
, input
.get (), debugfile
);
871 do_cleanups (cleanups
);
875 /* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
879 auto_load_objfile_script (struct objfile
*objfile
,
880 const struct extension_language_defn
*language
)
882 gdb::unique_xmalloc_ptr
<char> realname
883 = gdb_realpath (objfile_name (objfile
));
885 if (!auto_load_objfile_script_1 (objfile
, realname
.get (), language
))
887 /* For Windows/DOS .exe executables, strip the .exe suffix, so that
888 FOO-gdb.gdb could be used for FOO.exe, and try again. */
890 size_t len
= strlen (realname
.get ());
891 const size_t lexe
= sizeof (".exe") - 1;
893 if (len
> lexe
&& strcasecmp (realname
.get () + len
- lexe
, ".exe") == 0)
896 realname
.get ()[len
] = '\0';
898 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Stripped .exe suffix, "
899 "retrying with \"%s\".\n"),
901 auto_load_objfile_script_1 (objfile
, realname
.get (), language
);
906 /* Subroutine of source_section_scripts to simplify it.
907 Load FILE as a script in extension language LANGUAGE.
908 The script is from section SECTION_NAME in OBJFILE at offset OFFSET. */
911 source_script_file (struct auto_load_pspace_info
*pspace_info
,
912 struct objfile
*objfile
,
913 const struct extension_language_defn
*language
,
914 const char *section_name
, unsigned int offset
,
918 objfile_script_sourcer_func
*sourcer
;
920 /* Skip this script if support is not compiled in. */
921 sourcer
= ext_lang_objfile_script_sourcer (language
);
924 /* We don't throw an error, the program is still debuggable. */
925 maybe_print_unsupported_script_warning (pspace_info
, objfile
, language
,
926 section_name
, offset
);
927 /* We *could* still try to open it, but there's no point. */
928 maybe_add_script_file (pspace_info
, 0, file
, NULL
, language
);
932 /* Skip this script if auto-loading it has been disabled. */
933 if (!ext_lang_auto_load_enabled (language
))
935 /* No message is printed, just skip it. */
939 gdb::optional
<open_script
> opened
= find_and_open_script (file
,
944 if (!file_is_auto_load_safe (opened
->full_path
.get (),
945 _("auto-load: Loading %s script "
946 "\"%s\" from section \"%s\" of "
947 "objfile \"%s\".\n"),
948 ext_lang_name (language
),
949 opened
->full_path
.get (),
950 section_name
, objfile_name (objfile
)))
955 /* If one script isn't found it's not uncommon for more to not be
956 found either. We don't want to print a message for each script,
957 too much noise. Instead, we print the warning once and tell the
958 user how to find the list of scripts that weren't loaded.
959 We don't throw an error, the program is still debuggable.
961 IWBN if complaints.c were more general-purpose. */
963 maybe_print_script_not_found_warning (pspace_info
, objfile
, language
,
964 section_name
, offset
);
967 in_hash_table
= maybe_add_script_file (pspace_info
, bool (opened
), file
,
969 ? opened
->full_path
.get ()
973 /* If this file is not currently loaded, load it. */
974 if (opened
&& !in_hash_table
)
975 sourcer (language
, objfile
, opened
->stream
.get (),
976 opened
->full_path
.get ());
979 /* Subroutine of source_section_scripts to simplify it.
980 Execute SCRIPT as a script in extension language LANG.
981 The script is from section SECTION_NAME in OBJFILE at offset OFFSET. */
984 execute_script_contents (struct auto_load_pspace_info
*pspace_info
,
985 struct objfile
*objfile
,
986 const struct extension_language_defn
*language
,
987 const char *section_name
, unsigned int offset
,
990 objfile_script_executor_func
*executor
;
991 const char *newline
, *script_text
;
993 int is_safe
, in_hash_table
;
995 /* The first line of the script is the name of the script.
996 It must not contain any kind of space character. */
998 newline
= strchr (script
, '\n');
999 std::string name_holder
;
1000 if (newline
!= NULL
)
1002 const char *buf
, *p
;
1004 /* Put the name in a buffer and validate it. */
1005 name_holder
= std::string (script
, newline
- script
);
1006 buf
= name_holder
.c_str ();
1007 for (p
= buf
; *p
!= '\0'; ++p
)
1012 /* We don't allow nameless scripts, they're not helpful to the user. */
1013 if (p
!= buf
&& *p
== '\0')
1018 /* We don't throw an error, the program is still debuggable. */
1020 Missing/bad script name in entry at offset %u in section %s\n\
1022 offset
, section_name
, objfile_name (objfile
));
1025 script_text
= newline
+ 1;
1027 /* Skip this script if support is not compiled in. */
1028 executor
= ext_lang_objfile_script_executor (language
);
1029 if (executor
== NULL
)
1031 /* We don't throw an error, the program is still debuggable. */
1032 maybe_print_unsupported_script_warning (pspace_info
, objfile
, language
,
1033 section_name
, offset
);
1034 maybe_add_script_text (pspace_info
, 0, name
, language
);
1038 /* Skip this script if auto-loading it has been disabled. */
1039 if (!ext_lang_auto_load_enabled (language
))
1041 /* No message is printed, just skip it. */
1045 is_safe
= file_is_auto_load_safe (objfile_name (objfile
),
1046 _("auto-load: Loading %s script "
1047 "\"%s\" from section \"%s\" of "
1048 "objfile \"%s\".\n"),
1049 ext_lang_name (language
), name
,
1050 section_name
, objfile_name (objfile
));
1052 in_hash_table
= maybe_add_script_text (pspace_info
, is_safe
, name
, language
);
1054 /* If this file is not currently loaded, load it. */
1055 if (is_safe
&& !in_hash_table
)
1056 executor (language
, objfile
, name
, script_text
);
1059 /* Load scripts specified in OBJFILE.
1060 START,END delimit a buffer containing a list of nul-terminated
1062 SECTION_NAME is used in error messages.
1064 Scripts specified as file names are found per normal "source -s" command
1065 processing. First the script is looked for in $cwd. If not found there
1066 the source search path is used.
1068 The section contains a list of path names of script files to load or
1069 actual script contents. Each entry is nul-terminated. */
1072 source_section_scripts (struct objfile
*objfile
, const char *section_name
,
1073 const char *start
, const char *end
)
1076 struct auto_load_pspace_info
*pspace_info
;
1078 pspace_info
= get_auto_load_pspace_data_for_loading (current_program_space
);
1080 for (p
= start
; p
< end
; ++p
)
1083 const struct extension_language_defn
*language
;
1084 unsigned int offset
= p
- start
;
1089 case SECTION_SCRIPT_ID_PYTHON_FILE
:
1090 case SECTION_SCRIPT_ID_PYTHON_TEXT
:
1091 language
= get_ext_lang_defn (EXT_LANG_PYTHON
);
1093 case SECTION_SCRIPT_ID_SCHEME_FILE
:
1094 case SECTION_SCRIPT_ID_SCHEME_TEXT
:
1095 language
= get_ext_lang_defn (EXT_LANG_GUILE
);
1098 warning (_("Invalid entry in %s section"), section_name
);
1099 /* We could try various heuristics to find the next valid entry,
1100 but it's safer to just punt. */
1105 while (p
< end
&& *p
!= '\0')
1109 warning (_("Non-nul-terminated entry in %s at offset %u"),
1110 section_name
, offset
);
1111 /* Don't load/execute it. */
1117 case SECTION_SCRIPT_ID_PYTHON_FILE
:
1118 case SECTION_SCRIPT_ID_SCHEME_FILE
:
1121 warning (_("Empty entry in %s at offset %u"),
1122 section_name
, offset
);
1125 source_script_file (pspace_info
, objfile
, language
,
1126 section_name
, offset
, entry
);
1128 case SECTION_SCRIPT_ID_PYTHON_TEXT
:
1129 case SECTION_SCRIPT_ID_SCHEME_TEXT
:
1130 execute_script_contents (pspace_info
, objfile
, language
,
1131 section_name
, offset
, entry
);
1137 /* Load scripts specified in section SECTION_NAME of OBJFILE. */
1140 auto_load_section_scripts (struct objfile
*objfile
, const char *section_name
)
1142 bfd
*abfd
= objfile
->obfd
;
1143 asection
*scripts_sect
;
1144 bfd_byte
*data
= NULL
;
1146 scripts_sect
= bfd_get_section_by_name (abfd
, section_name
);
1147 if (scripts_sect
== NULL
1148 || (bfd_get_section_flags (abfd
, scripts_sect
) & SEC_HAS_CONTENTS
) == 0)
1151 if (!bfd_get_full_section_contents (abfd
, scripts_sect
, &data
))
1152 warning (_("Couldn't read %s section of %s"),
1153 section_name
, bfd_get_filename (abfd
));
1156 struct cleanup
*cleanups
;
1157 char *p
= (char *) data
;
1159 cleanups
= make_cleanup (xfree
, p
);
1160 source_section_scripts (objfile
, section_name
, p
,
1161 p
+ bfd_get_section_size (scripts_sect
));
1162 do_cleanups (cleanups
);
1166 /* Load any auto-loaded scripts for OBJFILE. */
1169 load_auto_scripts_for_objfile (struct objfile
*objfile
)
1171 /* Return immediately if auto-loading has been globally disabled.
1172 This is to handle sequencing of operations during gdb startup.
1173 Also return immediately if OBJFILE was not created from a file
1174 on the local filesystem. */
1175 if (!global_auto_load
1176 || (objfile
->flags
& OBJF_NOT_FILENAME
) != 0
1177 || is_target_filename (objfile
->original_name
))
1180 /* Load any extension language scripts for this objfile.
1181 E.g., foo-gdb.gdb, foo-gdb.py. */
1182 auto_load_ext_lang_scripts_for_objfile (objfile
);
1184 /* Load any scripts mentioned in AUTO_SECTION_NAME (.debug_gdb_scripts). */
1185 auto_load_section_scripts (objfile
, AUTO_SECTION_NAME
);
1188 /* This is a new_objfile observer callback to auto-load scripts.
1190 Two flavors of auto-loaded scripts are supported.
1191 1) based on the path to the objfile
1192 2) from .debug_gdb_scripts section */
1195 auto_load_new_objfile (struct objfile
*objfile
)
1199 /* OBJFILE is NULL when loading a new "main" symbol-file. */
1200 clear_section_scripts ();
1204 load_auto_scripts_for_objfile (objfile
);
1207 /* Collect scripts to be printed in a vec. */
1209 struct collect_matching_scripts_data
1211 collect_matching_scripts_data (std::vector
<loaded_script
*> *scripts_p_
,
1212 const extension_language_defn
*language_
)
1213 : scripts_p (scripts_p_
), language (language_
)
1216 std::vector
<loaded_script
*> *scripts_p
;
1217 const struct extension_language_defn
*language
;
1220 /* Traversal function for htab_traverse.
1221 Collect the entry if it matches the regexp. */
1224 collect_matching_scripts (void **slot
, void *info
)
1226 struct loaded_script
*script
= (struct loaded_script
*) *slot
;
1227 struct collect_matching_scripts_data
*data
1228 = (struct collect_matching_scripts_data
*) info
;
1230 if (script
->language
== data
->language
&& re_exec (script
->name
))
1231 data
->scripts_p
->push_back (script
);
1239 print_script (struct loaded_script
*script
)
1241 struct ui_out
*uiout
= current_uiout
;
1243 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1245 uiout
->field_string ("loaded", script
->loaded
? "Yes" : "No");
1246 uiout
->field_string ("script", script
->name
);
1249 /* If the name isn't the full path, print it too. */
1250 if (script
->full_path
!= NULL
1251 && strcmp (script
->name
, script
->full_path
) != 0)
1253 uiout
->text ("\tfull name: ");
1254 uiout
->field_string ("full_path", script
->full_path
);
1259 /* Helper for info_auto_load_scripts to sort the scripts by name. */
1262 sort_scripts_by_name (loaded_script
*a
, loaded_script
*b
)
1264 return FILENAME_CMP (a
->name
, b
->name
) < 0;
1267 /* Special internal GDB value of auto_load_info_scripts's PATTERN identify
1268 the "info auto-load XXX" command has been executed through the general
1269 "info auto-load" invocation. Extra newline will be printed if needed. */
1270 char auto_load_info_scripts_pattern_nl
[] = "";
1272 /* Subroutine of auto_load_info_scripts to simplify it.
1276 print_scripts (const std::vector
<loaded_script
*> &scripts
)
1278 for (loaded_script
*script
: scripts
)
1279 print_script (script
);
1282 /* Implementation for "info auto-load gdb-scripts"
1283 (and "info auto-load python-scripts"). List scripts in LANGUAGE matching
1284 PATTERN. FROM_TTY is the usual GDB boolean for user interactivity. */
1287 auto_load_info_scripts (const char *pattern
, int from_tty
,
1288 const struct extension_language_defn
*language
)
1290 struct ui_out
*uiout
= current_uiout
;
1291 struct auto_load_pspace_info
*pspace_info
;
1295 pspace_info
= get_auto_load_pspace_data (current_program_space
);
1297 if (pattern
&& *pattern
)
1299 char *re_err
= re_comp (pattern
);
1302 error (_("Invalid regexp: %s"), re_err
);
1309 /* We need to know the number of rows before we build the table.
1310 Plus we want to sort the scripts by name.
1311 So first traverse the hash table collecting the matching scripts. */
1313 std::vector
<loaded_script
*> script_files
, script_texts
;
1315 if (pspace_info
!= NULL
&& pspace_info
->loaded_script_files
!= NULL
)
1317 collect_matching_scripts_data
data (&script_files
, language
);
1319 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
1320 htab_traverse_noresize (pspace_info
->loaded_script_files
,
1321 collect_matching_scripts
, &data
);
1323 std::sort (script_files
.begin (), script_files
.end (),
1324 sort_scripts_by_name
);
1327 if (pspace_info
!= NULL
&& pspace_info
->loaded_script_texts
!= NULL
)
1329 collect_matching_scripts_data
data (&script_texts
, language
);
1331 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
1332 htab_traverse_noresize (pspace_info
->loaded_script_texts
,
1333 collect_matching_scripts
, &data
);
1335 std::sort (script_texts
.begin (), script_texts
.end (),
1336 sort_scripts_by_name
);
1339 int nr_scripts
= script_files
.size () + script_texts
.size ();
1341 /* Table header shifted right by preceding "gdb-scripts: " would not match
1343 if (nr_scripts
> 0 && pattern
== auto_load_info_scripts_pattern_nl
)
1347 ui_out_emit_table
table_emitter (uiout
, 2, nr_scripts
,
1348 "AutoLoadedScriptsTable");
1350 uiout
->table_header (7, ui_left
, "loaded", "Loaded");
1351 uiout
->table_header (70, ui_left
, "script", "Script");
1352 uiout
->table_body ();
1354 print_scripts (script_files
);
1355 print_scripts (script_texts
);
1358 if (nr_scripts
== 0)
1360 if (pattern
&& *pattern
)
1361 uiout
->message ("No auto-load scripts matching %s.\n", pattern
);
1363 uiout
->message ("No auto-load scripts.\n");
1367 /* Wrapper for "info auto-load gdb-scripts". */
1370 info_auto_load_gdb_scripts (const char *pattern
, int from_tty
)
1372 auto_load_info_scripts (pattern
, from_tty
, &extension_language_gdb
);
1375 /* Implement 'info auto-load local-gdbinit'. */
1378 info_auto_load_local_gdbinit (const char *args
, int from_tty
)
1380 if (auto_load_local_gdbinit_pathname
== NULL
)
1381 printf_filtered (_("Local .gdbinit file was not found.\n"));
1382 else if (auto_load_local_gdbinit_loaded
)
1383 printf_filtered (_("Local .gdbinit file \"%s\" has been loaded.\n"),
1384 auto_load_local_gdbinit_pathname
);
1386 printf_filtered (_("Local .gdbinit file \"%s\" has not been loaded.\n"),
1387 auto_load_local_gdbinit_pathname
);
1390 /* Print an "unsupported script" warning if it has not already been printed.
1391 The script is in language LANGUAGE at offset OFFSET in section SECTION_NAME
1395 maybe_print_unsupported_script_warning
1396 (struct auto_load_pspace_info
*pspace_info
,
1397 struct objfile
*objfile
, const struct extension_language_defn
*language
,
1398 const char *section_name
, unsigned offset
)
1400 if (!pspace_info
->unsupported_script_warning_printed
)
1403 Unsupported auto-load script at offset %u in section %s\n\
1405 Use `info auto-load %s-scripts [REGEXP]' to list them."),
1406 offset
, section_name
, objfile_name (objfile
),
1407 ext_lang_name (language
));
1408 pspace_info
->unsupported_script_warning_printed
= 1;
1412 /* Return non-zero if SCRIPT_NOT_FOUND_WARNING_PRINTED of PSPACE_INFO was unset
1413 before calling this function. Always set SCRIPT_NOT_FOUND_WARNING_PRINTED
1417 maybe_print_script_not_found_warning
1418 (struct auto_load_pspace_info
*pspace_info
,
1419 struct objfile
*objfile
, const struct extension_language_defn
*language
,
1420 const char *section_name
, unsigned offset
)
1422 if (!pspace_info
->script_not_found_warning_printed
)
1425 Missing auto-load script at offset %u in section %s\n\
1427 Use `info auto-load %s-scripts [REGEXP]' to list them."),
1428 offset
, section_name
, objfile_name (objfile
),
1429 ext_lang_name (language
));
1430 pspace_info
->script_not_found_warning_printed
= 1;
1434 /* The only valid "set auto-load" argument is off|0|no|disable. */
1437 set_auto_load_cmd (const char *args
, int from_tty
)
1439 struct cmd_list_element
*list
;
1442 /* See parse_binary_operation in use by the sub-commands. */
1444 length
= args
? strlen (args
) : 0;
1446 while (length
> 0 && (args
[length
- 1] == ' ' || args
[length
- 1] == '\t'))
1449 if (length
== 0 || (strncmp (args
, "off", length
) != 0
1450 && strncmp (args
, "0", length
) != 0
1451 && strncmp (args
, "no", length
) != 0
1452 && strncmp (args
, "disable", length
) != 0))
1453 error (_("Valid is only global 'set auto-load no'; "
1454 "otherwise check the auto-load sub-commands."));
1456 for (list
= *auto_load_set_cmdlist_get (); list
!= NULL
; list
= list
->next
)
1457 if (list
->var_type
== var_boolean
)
1459 gdb_assert (list
->type
== set_cmd
);
1460 do_set_command (args
, from_tty
, list
);
1464 /* Initialize "set auto-load " commands prefix and return it. */
1466 struct cmd_list_element
**
1467 auto_load_set_cmdlist_get (void)
1469 static struct cmd_list_element
*retval
;
1472 add_prefix_cmd ("auto-load", class_maintenance
, set_auto_load_cmd
, _("\
1473 Auto-loading specific settings.\n\
1474 Configure various auto-load-specific variables such as\n\
1475 automatic loading of Python scripts."),
1476 &retval
, "set auto-load ",
1477 1/*allow-unknown*/, &setlist
);
1482 /* Command "show auto-load" displays summary of all the current
1483 "show auto-load " settings. */
1486 show_auto_load_cmd (const char *args
, int from_tty
)
1488 cmd_show_list (*auto_load_show_cmdlist_get (), from_tty
, "");
1491 /* Initialize "show auto-load " commands prefix and return it. */
1493 struct cmd_list_element
**
1494 auto_load_show_cmdlist_get (void)
1496 static struct cmd_list_element
*retval
;
1499 add_prefix_cmd ("auto-load", class_maintenance
, show_auto_load_cmd
, _("\
1500 Show auto-loading specific settings.\n\
1501 Show configuration of various auto-load-specific variables such as\n\
1502 automatic loading of Python scripts."),
1503 &retval
, "show auto-load ",
1504 0/*allow-unknown*/, &showlist
);
1509 /* Command "info auto-load" displays whether the various auto-load files have
1510 been loaded. This is reimplementation of cmd_show_list which inserts
1511 newlines at proper places. */
1514 info_auto_load_cmd (const char *args
, int from_tty
)
1516 struct cmd_list_element
*list
;
1517 struct ui_out
*uiout
= current_uiout
;
1519 ui_out_emit_tuple
tuple_emitter (uiout
, "infolist");
1521 for (list
= *auto_load_info_cmdlist_get (); list
!= NULL
; list
= list
->next
)
1523 ui_out_emit_tuple
option_emitter (uiout
, "option");
1525 gdb_assert (!list
->prefixlist
);
1526 gdb_assert (list
->type
== not_set_cmd
);
1528 uiout
->field_string ("name", list
->name
);
1530 cmd_func (list
, auto_load_info_scripts_pattern_nl
, from_tty
);
1534 /* Initialize "info auto-load " commands prefix and return it. */
1536 struct cmd_list_element
**
1537 auto_load_info_cmdlist_get (void)
1539 static struct cmd_list_element
*retval
;
1542 add_prefix_cmd ("auto-load", class_info
, info_auto_load_cmd
, _("\
1543 Print current status of auto-loaded files.\n\
1544 Print whether various files like Python scripts or .gdbinit files have been\n\
1545 found and/or loaded."),
1546 &retval
, "info auto-load ",
1547 0/*allow-unknown*/, &infolist
);
1553 _initialize_auto_load (void)
1555 struct cmd_list_element
*cmd
;
1556 char *scripts_directory_help
, *gdb_name_help
, *python_name_help
;
1557 char *guile_name_help
;
1560 auto_load_pspace_data
1561 = register_program_space_data_with_cleanup (NULL
,
1562 auto_load_pspace_data_cleanup
);
1564 observer_attach_new_objfile (auto_load_new_objfile
);
1566 add_setshow_boolean_cmd ("gdb-scripts", class_support
,
1567 &auto_load_gdb_scripts
, _("\
1568 Enable or disable auto-loading of canned sequences of commands scripts."), _("\
1569 Show whether auto-loading of canned sequences of commands scripts is enabled."),
1571 If enabled, canned sequences of commands are loaded when the debugger reads\n\
1572 an executable or shared library.\n\
1573 This options has security implications for untrusted inferiors."),
1574 NULL
, show_auto_load_gdb_scripts
,
1575 auto_load_set_cmdlist_get (),
1576 auto_load_show_cmdlist_get ());
1578 add_cmd ("gdb-scripts", class_info
, info_auto_load_gdb_scripts
,
1579 _("Print the list of automatically loaded sequences of commands.\n\
1580 Usage: info auto-load gdb-scripts [REGEXP]"),
1581 auto_load_info_cmdlist_get ());
1583 add_setshow_boolean_cmd ("local-gdbinit", class_support
,
1584 &auto_load_local_gdbinit
, _("\
1585 Enable or disable auto-loading of .gdbinit script in current directory."), _("\
1586 Show whether auto-loading .gdbinit script in current directory is enabled."),
1588 If enabled, canned sequences of commands are loaded when debugger starts\n\
1589 from .gdbinit file in current directory. Such files are deprecated,\n\
1590 use a script associated with inferior executable file instead.\n\
1591 This options has security implications for untrusted inferiors."),
1592 NULL
, show_auto_load_local_gdbinit
,
1593 auto_load_set_cmdlist_get (),
1594 auto_load_show_cmdlist_get ());
1596 add_cmd ("local-gdbinit", class_info
, info_auto_load_local_gdbinit
,
1597 _("Print whether current directory .gdbinit file has been loaded.\n\
1598 Usage: info auto-load local-gdbinit"),
1599 auto_load_info_cmdlist_get ());
1601 auto_load_dir
= xstrdup (AUTO_LOAD_DIR
);
1603 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GDB
));
1606 GDB scripts: OBJFILE%s\n"),
1608 python_name_help
= NULL
;
1610 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_PYTHON
));
1613 Python scripts: OBJFILE%s\n"),
1616 guile_name_help
= NULL
;
1618 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GUILE
));
1621 Guile scripts: OBJFILE%s\n"),
1624 scripts_directory_help
1626 Automatically loaded scripts are located in one of the directories listed\n\
1632 This option is ignored for the kinds of scripts \
1633 having 'set auto-load ... off'.\n\
1634 Directories listed here need to be present also \
1635 in the 'set auto-load safe-path'\n\
1638 python_name_help
? python_name_help
: "",
1639 guile_name_help
? guile_name_help
: "");
1641 add_setshow_optional_filename_cmd ("scripts-directory", class_support
,
1642 &auto_load_dir
, _("\
1643 Set the list of directories from which to load auto-loaded scripts."), _("\
1644 Show the list of directories from which to load auto-loaded scripts."),
1645 scripts_directory_help
,
1646 set_auto_load_dir
, show_auto_load_dir
,
1647 auto_load_set_cmdlist_get (),
1648 auto_load_show_cmdlist_get ());
1649 xfree (scripts_directory_help
);
1650 xfree (python_name_help
);
1651 xfree (gdb_name_help
);
1652 xfree (guile_name_help
);
1654 auto_load_safe_path
= xstrdup (AUTO_LOAD_SAFE_PATH
);
1655 auto_load_safe_path_vec_update ();
1656 add_setshow_optional_filename_cmd ("safe-path", class_support
,
1657 &auto_load_safe_path
, _("\
1658 Set the list of files and directories that are safe for auto-loading."), _("\
1659 Show the list of files and directories that are safe for auto-loading."), _("\
1660 Various files loaded automatically for the 'set auto-load ...' options must\n\
1661 be located in one of the directories listed by this option. Warning will be\n\
1662 printed and file will not be used otherwise.\n\
1663 You can mix both directory and filename entries.\n\
1664 Setting this parameter to an empty list resets it to its default value.\n\
1665 Setting this parameter to '/' (without the quotes) allows any file\n\
1666 for the 'set auto-load ...' options. Each path entry can be also shell\n\
1667 wildcard pattern; '*' does not match directory separator.\n\
1668 This option is ignored for the kinds of files having 'set auto-load ... off'.\n\
1669 This options has security implications for untrusted inferiors."),
1670 set_auto_load_safe_path
,
1671 show_auto_load_safe_path
,
1672 auto_load_set_cmdlist_get (),
1673 auto_load_show_cmdlist_get ());
1674 observer_attach_gdb_datadir_changed (auto_load_gdb_datadir_changed
);
1676 cmd
= add_cmd ("add-auto-load-safe-path", class_support
,
1677 add_auto_load_safe_path
,
1678 _("Add entries to the list of directories from which it is safe "
1679 "to auto-load files.\n\
1680 See the commands 'set auto-load safe-path' and 'show auto-load safe-path' to\n\
1681 access the current full list setting."),
1683 set_cmd_completer (cmd
, filename_completer
);
1685 cmd
= add_cmd ("add-auto-load-scripts-directory", class_support
,
1687 _("Add entries to the list of directories from which to load "
1688 "auto-loaded scripts.\n\
1689 See the commands 'set auto-load scripts-directory' and\n\
1690 'show auto-load scripts-directory' to access the current full list setting."),
1692 set_cmd_completer (cmd
, filename_completer
);
1694 add_setshow_boolean_cmd ("auto-load", class_maintenance
,
1695 &debug_auto_load
, _("\
1696 Set auto-load verifications debugging."), _("\
1697 Show auto-load verifications debugging."), _("\
1698 When non-zero, debugging output for files of 'set auto-load ...'\n\
1700 NULL
, show_debug_auto_load
,
1701 &setdebuglist
, &showdebuglist
);