1 /* GDB routines for supporting auto-loaded scripts.
3 Copyright (C) 2012-2017 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"
36 #include "readline/tilde.h"
37 #include "completer.h"
40 #include "filestuff.h"
41 #include "extension.h"
42 #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 (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 (char *args
, int from_tty
, struct cmd_list_element
*c
)
267 /* Setting the variable to "" resets it to the compile time defaults. */
268 if (auto_load_safe_path
[0] == '\0')
270 xfree (auto_load_safe_path
);
271 auto_load_safe_path
= xstrdup (AUTO_LOAD_SAFE_PATH
);
274 auto_load_safe_path_vec_update ();
277 /* "show" command for the auto_load_safe_path configuration variable. */
280 show_auto_load_safe_path (struct ui_file
*file
, int from_tty
,
281 struct cmd_list_element
*c
, const char *value
)
285 /* Check if user has entered either "/" or for example ":".
286 But while more complicate content like ":/foo" would still also
287 permit any location do not hide those. */
289 for (cs
= value
; *cs
&& (*cs
== DIRNAME_SEPARATOR
|| IS_DIR_SEPARATOR (*cs
));
292 fprintf_filtered (file
, _("Auto-load files are safe to load from any "
295 fprintf_filtered (file
, _("List of directories from which it is safe to "
296 "auto-load files is %s.\n"),
300 /* "add-auto-load-safe-path" command for the auto_load_safe_path configuration
304 add_auto_load_safe_path (char *args
, int from_tty
)
308 if (args
== NULL
|| *args
== 0)
310 Directory argument required.\n\
311 Use 'set auto-load safe-path /' for disabling the auto-load safe-path security.\
314 s
= xstrprintf ("%s%c%s", auto_load_safe_path
, DIRNAME_SEPARATOR
, args
);
315 xfree (auto_load_safe_path
);
316 auto_load_safe_path
= s
;
318 auto_load_safe_path_vec_update ();
321 /* "add-auto-load-scripts-directory" command for the auto_load_dir configuration
325 add_auto_load_dir (char *args
, int from_tty
)
329 if (args
== NULL
|| *args
== 0)
330 error (_("Directory argument required."));
332 s
= xstrprintf ("%s%c%s", auto_load_dir
, DIRNAME_SEPARATOR
, args
);
333 xfree (auto_load_dir
);
337 /* Implementation for filename_is_in_pattern overwriting the caller's FILENAME
341 filename_is_in_pattern_1 (char *filename
, char *pattern
)
343 size_t pattern_len
= strlen (pattern
);
344 size_t filename_len
= strlen (filename
);
347 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Matching file \"%s\" "
348 "to pattern \"%s\"\n"),
351 /* Trim trailing slashes ("/") from PATTERN. Even for "d:\" paths as
352 trailing slashes are trimmed also from FILENAME it still matches
354 while (pattern_len
&& IS_DIR_SEPARATOR (pattern
[pattern_len
- 1]))
356 pattern
[pattern_len
] = '\0';
358 /* Ensure auto_load_safe_path "/" matches any FILENAME. On MS-Windows
359 platform FILENAME even after gdb_realpath does not have to start with
360 IS_DIR_SEPARATOR character, such as the 'C:\x.exe' filename. */
361 if (pattern_len
== 0)
364 fprintf_unfiltered (gdb_stdlog
,
365 _("auto-load: Matched - empty pattern\n"));
371 /* Trim trailing slashes ("/"). PATTERN also has slashes trimmed the
372 same way so they will match. */
373 while (filename_len
&& IS_DIR_SEPARATOR (filename
[filename_len
- 1]))
375 filename
[filename_len
] = '\0';
376 if (filename_len
== 0)
379 fprintf_unfiltered (gdb_stdlog
,
380 _("auto-load: Not matched - pattern \"%s\".\n"),
385 if (gdb_filename_fnmatch (pattern
, filename
, FNM_FILE_NAME
| FNM_NOESCAPE
)
389 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Matched - file "
390 "\"%s\" to pattern \"%s\".\n"),
395 /* Trim trailing FILENAME component. */
396 while (filename_len
> 0 && !IS_DIR_SEPARATOR (filename
[filename_len
- 1]))
401 /* Return 1 if FILENAME matches PATTERN or if FILENAME resides in
402 a subdirectory of a directory that matches PATTERN. Return 0 otherwise.
403 gdb_realpath normalization is never done here. */
405 static ATTRIBUTE_PURE
int
406 filename_is_in_pattern (const char *filename
, const char *pattern
)
408 char *filename_copy
, *pattern_copy
;
410 filename_copy
= (char *) alloca (strlen (filename
) + 1);
411 strcpy (filename_copy
, filename
);
412 pattern_copy
= (char *) alloca (strlen (pattern
) + 1);
413 strcpy (pattern_copy
, pattern
);
415 return filename_is_in_pattern_1 (filename_copy
, pattern_copy
);
418 /* Return 1 if FILENAME belongs to one of directory components of
419 AUTO_LOAD_SAFE_PATH_VEC. Return 0 otherwise.
420 auto_load_safe_path_vec_update is never called.
421 *FILENAME_REALP may be updated by gdb_realpath of FILENAME. */
424 filename_is_in_auto_load_safe_path_vec (const char *filename
,
425 gdb::unique_xmalloc_ptr
<char> *filename_realp
)
430 for (ix
= 0; VEC_iterate (char_ptr
, auto_load_safe_path_vec
, ix
, pattern
);
432 if (*filename_realp
== NULL
&& filename_is_in_pattern (filename
, pattern
))
437 if (*filename_realp
== NULL
)
439 *filename_realp
= gdb_realpath (filename
);
440 if (debug_auto_load
&& strcmp (filename_realp
->get (), filename
) != 0)
441 fprintf_unfiltered (gdb_stdlog
,
442 _("auto-load: Resolved "
443 "file \"%s\" as \"%s\".\n"),
444 filename
, filename_realp
->get ());
447 if (strcmp (filename_realp
->get (), filename
) != 0)
449 VEC_iterate (char_ptr
, auto_load_safe_path_vec
, ix
, pattern
); ++ix
)
450 if (filename_is_in_pattern (filename_realp
->get (), pattern
))
457 fprintf_unfiltered (gdb_stdlog
, _("auto-load: File \"%s\" matches "
458 "directory \"%s\".\n"),
466 /* Return 1 if FILENAME is located in one of the directories of
467 AUTO_LOAD_SAFE_PATH. Otherwise call warning and return 0. FILENAME does
468 not have to be an absolute path.
470 Existence of FILENAME is not checked. Function will still give a warning
471 even if the caller would quietly skip non-existing file in unsafe
475 file_is_auto_load_safe (const char *filename
, const char *debug_fmt
, ...)
477 gdb::unique_xmalloc_ptr
<char> filename_real
;
478 static int advice_printed
= 0;
484 va_start (debug_args
, debug_fmt
);
485 vfprintf_unfiltered (gdb_stdlog
, debug_fmt
, debug_args
);
489 if (filename_is_in_auto_load_safe_path_vec (filename
, &filename_real
))
492 auto_load_safe_path_vec_update ();
493 if (filename_is_in_auto_load_safe_path_vec (filename
, &filename_real
))
496 warning (_("File \"%s\" auto-loading has been declined by your "
497 "`auto-load safe-path' set to \"%s\"."),
498 filename_real
.get (), auto_load_safe_path
);
502 const char *homedir
= getenv ("HOME");
506 std::string homeinit
= string_printf ("%s/%s", homedir
, gdbinit
);
508 printf_filtered (_("\
509 To enable execution of this file add\n\
510 \tadd-auto-load-safe-path %s\n\
511 line to your configuration file \"%s\".\n\
512 To completely disable this security protection add\n\
513 \tset auto-load safe-path /\n\
514 line to your configuration file \"%s\".\n\
515 For more information about this security protection see the\n\
516 \"Auto-loading safe path\" section in the GDB manual. E.g., run from the shell:\n\
517 \tinfo \"(gdb)Auto-loading safe path\"\n"),
518 filename_real
.get (),
519 homeinit
.c_str (), homeinit
.c_str ());
526 /* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
527 the same script. There's no point in loading the script multiple times,
528 and there can be a lot of objfiles and scripts, so we keep track of scripts
531 struct auto_load_pspace_info
533 /* For each program space we keep track of loaded scripts, both when
534 specified as file names and as scripts to be executed directly. */
535 struct htab
*loaded_script_files
;
536 struct htab
*loaded_script_texts
;
538 /* Non-zero if we've issued the warning about an auto-load script not being
539 supported. We only want to issue this warning once. */
540 int unsupported_script_warning_printed
;
542 /* Non-zero if we've issued the warning about an auto-load script not being
543 found. We only want to issue this warning once. */
544 int script_not_found_warning_printed
;
547 /* Objects of this type are stored in the loaded_script hash table. */
551 /* Name as provided by the objfile. */
554 /* Full path name or NULL if script wasn't found (or was otherwise
555 inaccessible), or NULL for loaded_script_texts. */
556 const char *full_path
;
558 /* Non-zero if this script has been loaded. */
561 const struct extension_language_defn
*language
;
564 /* Per-program-space data key. */
565 static const struct program_space_data
*auto_load_pspace_data
;
568 auto_load_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
570 struct auto_load_pspace_info
*info
= (struct auto_load_pspace_info
*) arg
;
572 if (info
->loaded_script_files
)
573 htab_delete (info
->loaded_script_files
);
574 if (info
->loaded_script_texts
)
575 htab_delete (info
->loaded_script_texts
);
579 /* Get the current autoload data. If none is found yet, add it now. This
580 function always returns a valid object. */
582 static struct auto_load_pspace_info
*
583 get_auto_load_pspace_data (struct program_space
*pspace
)
585 struct auto_load_pspace_info
*info
;
587 info
= ((struct auto_load_pspace_info
*)
588 program_space_data (pspace
, auto_load_pspace_data
));
591 info
= XCNEW (struct auto_load_pspace_info
);
592 set_program_space_data (pspace
, auto_load_pspace_data
, info
);
598 /* Hash function for the loaded script hash. */
601 hash_loaded_script_entry (const void *data
)
603 const struct loaded_script
*e
= (const struct loaded_script
*) data
;
605 return htab_hash_string (e
->name
) ^ htab_hash_pointer (e
->language
);
608 /* Equality function for the loaded script hash. */
611 eq_loaded_script_entry (const void *a
, const void *b
)
613 const struct loaded_script
*ea
= (const struct loaded_script
*) a
;
614 const struct loaded_script
*eb
= (const struct loaded_script
*) b
;
616 return strcmp (ea
->name
, eb
->name
) == 0 && ea
->language
== eb
->language
;
619 /* Initialize the table to track loaded scripts.
620 Each entry is hashed by the full path name. */
623 init_loaded_scripts_info (struct auto_load_pspace_info
*pspace_info
)
625 /* Choose 31 as the starting size of the hash table, somewhat arbitrarily.
626 Space for each entry is obtained with one malloc so we can free them
629 pspace_info
->loaded_script_files
= htab_create (31,
630 hash_loaded_script_entry
,
631 eq_loaded_script_entry
,
633 pspace_info
->loaded_script_texts
= htab_create (31,
634 hash_loaded_script_entry
,
635 eq_loaded_script_entry
,
638 pspace_info
->unsupported_script_warning_printed
= FALSE
;
639 pspace_info
->script_not_found_warning_printed
= FALSE
;
642 /* Wrapper on get_auto_load_pspace_data to also allocate the hash table
643 for loading scripts. */
645 struct auto_load_pspace_info
*
646 get_auto_load_pspace_data_for_loading (struct program_space
*pspace
)
648 struct auto_load_pspace_info
*info
;
650 info
= get_auto_load_pspace_data (pspace
);
651 if (info
->loaded_script_files
== NULL
)
652 init_loaded_scripts_info (info
);
657 /* Add script file NAME in LANGUAGE to hash table of PSPACE_INFO.
658 LOADED 1 if the script has been (is going to) be loaded, 0 otherwise
659 (such as if it has not been found).
660 FULL_PATH is NULL if the script wasn't found.
661 The result is true if the script was already in the hash table. */
664 maybe_add_script_file (struct auto_load_pspace_info
*pspace_info
, int loaded
,
665 const char *name
, const char *full_path
,
666 const struct extension_language_defn
*language
)
668 struct htab
*htab
= pspace_info
->loaded_script_files
;
669 struct loaded_script
**slot
, entry
;
673 entry
.language
= language
;
674 slot
= (struct loaded_script
**) htab_find_slot (htab
, &entry
, INSERT
);
675 in_hash_table
= *slot
!= NULL
;
677 /* If this script is not in the hash table, add it. */
683 /* Allocate all space in one chunk so it's easier to free. */
684 *slot
= ((struct loaded_script
*)
685 xmalloc (sizeof (**slot
)
687 + (full_path
!= NULL
? (strlen (full_path
) + 1) : 0)));
688 p
= ((char*) *slot
) + sizeof (**slot
);
691 if (full_path
!= NULL
)
694 strcpy (p
, full_path
);
695 (*slot
)->full_path
= p
;
698 (*slot
)->full_path
= NULL
;
699 (*slot
)->loaded
= loaded
;
700 (*slot
)->language
= language
;
703 return in_hash_table
;
706 /* Add script contents NAME in LANGUAGE to hash table of PSPACE_INFO.
707 LOADED 1 if the script has been (is going to) be loaded, 0 otherwise
708 (such as if it has not been found).
709 The result is true if the script was already in the hash table. */
712 maybe_add_script_text (struct auto_load_pspace_info
*pspace_info
,
713 int loaded
, const char *name
,
714 const struct extension_language_defn
*language
)
716 struct htab
*htab
= pspace_info
->loaded_script_texts
;
717 struct loaded_script
**slot
, entry
;
721 entry
.language
= language
;
722 slot
= (struct loaded_script
**) htab_find_slot (htab
, &entry
, INSERT
);
723 in_hash_table
= *slot
!= NULL
;
725 /* If this script is not in the hash table, add it. */
731 /* Allocate all space in one chunk so it's easier to free. */
732 *slot
= ((struct loaded_script
*)
733 xmalloc (sizeof (**slot
) + strlen (name
) + 1));
734 p
= ((char*) *slot
) + sizeof (**slot
);
737 (*slot
)->full_path
= NULL
;
738 (*slot
)->loaded
= loaded
;
739 (*slot
)->language
= language
;
742 return in_hash_table
;
745 /* Clear the table of loaded section scripts. */
748 clear_section_scripts (void)
750 struct program_space
*pspace
= current_program_space
;
751 struct auto_load_pspace_info
*info
;
753 info
= ((struct auto_load_pspace_info
*)
754 program_space_data (pspace
, auto_load_pspace_data
));
755 if (info
!= NULL
&& info
->loaded_script_files
!= NULL
)
757 htab_delete (info
->loaded_script_files
);
758 htab_delete (info
->loaded_script_texts
);
759 info
->loaded_script_files
= NULL
;
760 info
->loaded_script_texts
= NULL
;
761 info
->unsupported_script_warning_printed
= FALSE
;
762 info
->script_not_found_warning_printed
= FALSE
;
766 /* Look for the auto-load script in LANGUAGE associated with OBJFILE where
767 OBJFILE's gdb_realpath is REALNAME and load it. Return 1 if we found any
768 matching script, return 0 otherwise. */
771 auto_load_objfile_script_1 (struct objfile
*objfile
, const char *realname
,
772 const struct extension_language_defn
*language
)
774 char *filename
, *debugfile
;
776 struct cleanup
*cleanups
;
777 const char *suffix
= ext_lang_auto_load_suffix (language
);
779 len
= strlen (realname
);
780 filename
= (char *) xmalloc (len
+ strlen (suffix
) + 1);
781 memcpy (filename
, realname
, len
);
782 strcpy (filename
+ len
, suffix
);
784 cleanups
= make_cleanup (xfree
, filename
);
786 gdb_file_up input
= gdb_fopen_cloexec (filename
, "r");
787 debugfile
= filename
;
789 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Attempted file \"%s\" %s.\n"),
790 debugfile
, input
? _("exists") : _("does not exist"));
798 /* Also try the same file in a subdirectory of gdb's data
801 vec
= auto_load_expand_dir_vars (auto_load_dir
);
802 make_cleanup_free_char_ptr_vec (vec
);
805 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Searching 'set auto-load "
806 "scripts-directory' path \"%s\".\n"),
809 for (ix
= 0; VEC_iterate (char_ptr
, vec
, ix
, dir
); ++ix
)
811 debugfile
= (char *) xmalloc (strlen (dir
) + strlen (filename
) + 1);
812 strcpy (debugfile
, dir
);
814 /* FILENAME is absolute, so we don't need a "/" here. */
815 strcat (debugfile
, filename
);
817 make_cleanup (xfree
, debugfile
);
818 input
= gdb_fopen_cloexec (debugfile
, "r");
820 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Attempted file "
823 input
? _("exists") : _("does not exist"));
832 struct auto_load_pspace_info
*pspace_info
;
835 = file_is_auto_load_safe (debugfile
,
836 _("auto-load: Loading %s script \"%s\""
837 " by extension for objfile \"%s\".\n"),
838 ext_lang_name (language
),
839 debugfile
, objfile_name (objfile
));
841 /* Add this script to the hash table too so
842 "info auto-load ${lang}-scripts" can print it. */
844 = get_auto_load_pspace_data_for_loading (current_program_space
);
845 maybe_add_script_file (pspace_info
, is_safe
, debugfile
, debugfile
,
848 /* To preserve existing behaviour we don't check for whether the
849 script was already in the table, and always load it.
850 It's highly unlikely that we'd ever load it twice,
851 and these scripts are required to be idempotent under multiple
855 objfile_script_sourcer_func
*sourcer
856 = ext_lang_objfile_script_sourcer (language
);
858 /* We shouldn't get here if support for the language isn't
859 compiled in. And the extension language is required to implement
861 gdb_assert (sourcer
!= NULL
);
862 sourcer (language
, objfile
, input
.get (), debugfile
);
870 do_cleanups (cleanups
);
874 /* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
878 auto_load_objfile_script (struct objfile
*objfile
,
879 const struct extension_language_defn
*language
)
881 gdb::unique_xmalloc_ptr
<char> realname
882 = gdb_realpath (objfile_name (objfile
));
884 if (!auto_load_objfile_script_1 (objfile
, realname
.get (), language
))
886 /* For Windows/DOS .exe executables, strip the .exe suffix, so that
887 FOO-gdb.gdb could be used for FOO.exe, and try again. */
889 size_t len
= strlen (realname
.get ());
890 const size_t lexe
= sizeof (".exe") - 1;
892 if (len
> lexe
&& strcasecmp (realname
.get () + len
- lexe
, ".exe") == 0)
895 realname
.get ()[len
] = '\0';
897 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Stripped .exe suffix, "
898 "retrying with \"%s\".\n"),
900 auto_load_objfile_script_1 (objfile
, realname
.get (), language
);
905 /* Subroutine of source_section_scripts to simplify it.
906 Load FILE as a script in extension language LANGUAGE.
907 The script is from section SECTION_NAME in OBJFILE at offset OFFSET. */
910 source_script_file (struct auto_load_pspace_info
*pspace_info
,
911 struct objfile
*objfile
,
912 const struct extension_language_defn
*language
,
913 const char *section_name
, unsigned int offset
,
917 objfile_script_sourcer_func
*sourcer
;
919 /* Skip this script if support is not compiled in. */
920 sourcer
= ext_lang_objfile_script_sourcer (language
);
923 /* We don't throw an error, the program is still debuggable. */
924 maybe_print_unsupported_script_warning (pspace_info
, objfile
, language
,
925 section_name
, offset
);
926 /* We *could* still try to open it, but there's no point. */
927 maybe_add_script_file (pspace_info
, 0, file
, NULL
, language
);
931 /* Skip this script if auto-loading it has been disabled. */
932 if (!ext_lang_auto_load_enabled (language
))
934 /* No message is printed, just skip it. */
938 gdb::optional
<open_script
> opened
= find_and_open_script (file
,
943 if (!file_is_auto_load_safe (opened
->full_path
.get (),
944 _("auto-load: Loading %s script "
945 "\"%s\" from section \"%s\" of "
946 "objfile \"%s\".\n"),
947 ext_lang_name (language
),
948 opened
->full_path
.get (),
949 section_name
, objfile_name (objfile
)))
954 /* If one script isn't found it's not uncommon for more to not be
955 found either. We don't want to print a message for each script,
956 too much noise. Instead, we print the warning once and tell the
957 user how to find the list of scripts that weren't loaded.
958 We don't throw an error, the program is still debuggable.
960 IWBN if complaints.c were more general-purpose. */
962 maybe_print_script_not_found_warning (pspace_info
, objfile
, language
,
963 section_name
, offset
);
966 in_hash_table
= maybe_add_script_file (pspace_info
, bool (opened
), file
,
968 ? opened
->full_path
.get ()
972 /* If this file is not currently loaded, load it. */
973 if (opened
&& !in_hash_table
)
974 sourcer (language
, objfile
, opened
->stream
.get (),
975 opened
->full_path
.get ());
978 /* Subroutine of source_section_scripts to simplify it.
979 Execute SCRIPT as a script in extension language LANG.
980 The script is from section SECTION_NAME in OBJFILE at offset OFFSET. */
983 execute_script_contents (struct auto_load_pspace_info
*pspace_info
,
984 struct objfile
*objfile
,
985 const struct extension_language_defn
*language
,
986 const char *section_name
, unsigned int offset
,
989 objfile_script_executor_func
*executor
;
990 const char *newline
, *script_text
;
992 int is_safe
, in_hash_table
;
993 struct cleanup
*cleanups
;
995 cleanups
= make_cleanup (null_cleanup
, NULL
);
997 /* The first line of the script is the name of the script.
998 It must not contain any kind of space character. */
1000 newline
= strchr (script
, '\n');
1001 if (newline
!= NULL
)
1005 /* Put the name in a buffer and validate it. */
1006 buf
= xstrndup (script
, newline
- script
);
1007 make_cleanup (xfree
, buf
);
1008 for (p
= buf
; *p
!= '\0'; ++p
)
1013 /* We don't allow nameless scripts, they're not helpful to the user. */
1014 if (p
!= buf
&& *p
== '\0')
1019 /* We don't throw an error, the program is still debuggable. */
1021 Missing/bad script name in entry at offset %u in section %s\n\
1023 offset
, section_name
, objfile_name (objfile
));
1024 do_cleanups (cleanups
);
1027 script_text
= newline
+ 1;
1029 /* Skip this script if support is not compiled in. */
1030 executor
= ext_lang_objfile_script_executor (language
);
1031 if (executor
== NULL
)
1033 /* We don't throw an error, the program is still debuggable. */
1034 maybe_print_unsupported_script_warning (pspace_info
, objfile
, language
,
1035 section_name
, offset
);
1036 maybe_add_script_text (pspace_info
, 0, name
, language
);
1037 do_cleanups (cleanups
);
1041 /* Skip this script if auto-loading it has been disabled. */
1042 if (!ext_lang_auto_load_enabled (language
))
1044 /* No message is printed, just skip it. */
1045 do_cleanups (cleanups
);
1049 is_safe
= file_is_auto_load_safe (objfile_name (objfile
),
1050 _("auto-load: Loading %s script "
1051 "\"%s\" from section \"%s\" of "
1052 "objfile \"%s\".\n"),
1053 ext_lang_name (language
), name
,
1054 section_name
, objfile_name (objfile
));
1056 in_hash_table
= maybe_add_script_text (pspace_info
, is_safe
, name
, language
);
1058 /* If this file is not currently loaded, load it. */
1059 if (is_safe
&& !in_hash_table
)
1060 executor (language
, objfile
, name
, script_text
);
1062 do_cleanups (cleanups
);
1065 /* Load scripts specified in OBJFILE.
1066 START,END delimit a buffer containing a list of nul-terminated
1068 SECTION_NAME is used in error messages.
1070 Scripts specified as file names are found per normal "source -s" command
1071 processing. First the script is looked for in $cwd. If not found there
1072 the source search path is used.
1074 The section contains a list of path names of script files to load or
1075 actual script contents. Each entry is nul-terminated. */
1078 source_section_scripts (struct objfile
*objfile
, const char *section_name
,
1079 const char *start
, const char *end
)
1082 struct auto_load_pspace_info
*pspace_info
;
1084 pspace_info
= get_auto_load_pspace_data_for_loading (current_program_space
);
1086 for (p
= start
; p
< end
; ++p
)
1089 const struct extension_language_defn
*language
;
1090 unsigned int offset
= p
- start
;
1095 case SECTION_SCRIPT_ID_PYTHON_FILE
:
1096 case SECTION_SCRIPT_ID_PYTHON_TEXT
:
1097 language
= get_ext_lang_defn (EXT_LANG_PYTHON
);
1099 case SECTION_SCRIPT_ID_SCHEME_FILE
:
1100 case SECTION_SCRIPT_ID_SCHEME_TEXT
:
1101 language
= get_ext_lang_defn (EXT_LANG_GUILE
);
1104 warning (_("Invalid entry in %s section"), section_name
);
1105 /* We could try various heuristics to find the next valid entry,
1106 but it's safer to just punt. */
1111 while (p
< end
&& *p
!= '\0')
1115 warning (_("Non-nul-terminated entry in %s at offset %u"),
1116 section_name
, offset
);
1117 /* Don't load/execute it. */
1123 case SECTION_SCRIPT_ID_PYTHON_FILE
:
1124 case SECTION_SCRIPT_ID_SCHEME_FILE
:
1127 warning (_("Empty entry in %s at offset %u"),
1128 section_name
, offset
);
1131 source_script_file (pspace_info
, objfile
, language
,
1132 section_name
, offset
, entry
);
1134 case SECTION_SCRIPT_ID_PYTHON_TEXT
:
1135 case SECTION_SCRIPT_ID_SCHEME_TEXT
:
1136 execute_script_contents (pspace_info
, objfile
, language
,
1137 section_name
, offset
, entry
);
1143 /* Load scripts specified in section SECTION_NAME of OBJFILE. */
1146 auto_load_section_scripts (struct objfile
*objfile
, const char *section_name
)
1148 bfd
*abfd
= objfile
->obfd
;
1149 asection
*scripts_sect
;
1150 bfd_byte
*data
= NULL
;
1152 scripts_sect
= bfd_get_section_by_name (abfd
, section_name
);
1153 if (scripts_sect
== NULL
1154 || (bfd_get_section_flags (abfd
, scripts_sect
) & SEC_HAS_CONTENTS
) == 0)
1157 if (!bfd_get_full_section_contents (abfd
, scripts_sect
, &data
))
1158 warning (_("Couldn't read %s section of %s"),
1159 section_name
, bfd_get_filename (abfd
));
1162 struct cleanup
*cleanups
;
1163 char *p
= (char *) data
;
1165 cleanups
= make_cleanup (xfree
, p
);
1166 source_section_scripts (objfile
, section_name
, p
,
1167 p
+ bfd_get_section_size (scripts_sect
));
1168 do_cleanups (cleanups
);
1172 /* Load any auto-loaded scripts for OBJFILE. */
1175 load_auto_scripts_for_objfile (struct objfile
*objfile
)
1177 /* Return immediately if auto-loading has been globally disabled.
1178 This is to handle sequencing of operations during gdb startup.
1179 Also return immediately if OBJFILE was not created from a file
1180 on the local filesystem. */
1181 if (!global_auto_load
1182 || (objfile
->flags
& OBJF_NOT_FILENAME
) != 0
1183 || is_target_filename (objfile
->original_name
))
1186 /* Load any extension language scripts for this objfile.
1187 E.g., foo-gdb.gdb, foo-gdb.py. */
1188 auto_load_ext_lang_scripts_for_objfile (objfile
);
1190 /* Load any scripts mentioned in AUTO_SECTION_NAME (.debug_gdb_scripts). */
1191 auto_load_section_scripts (objfile
, AUTO_SECTION_NAME
);
1194 /* This is a new_objfile observer callback to auto-load scripts.
1196 Two flavors of auto-loaded scripts are supported.
1197 1) based on the path to the objfile
1198 2) from .debug_gdb_scripts section */
1201 auto_load_new_objfile (struct objfile
*objfile
)
1205 /* OBJFILE is NULL when loading a new "main" symbol-file. */
1206 clear_section_scripts ();
1210 load_auto_scripts_for_objfile (objfile
);
1213 /* Collect scripts to be printed in a vec. */
1215 typedef struct loaded_script
*loaded_script_ptr
;
1216 DEF_VEC_P (loaded_script_ptr
);
1218 struct collect_matching_scripts_data
1220 VEC (loaded_script_ptr
) **scripts_p
;
1222 const struct extension_language_defn
*language
;
1225 /* Traversal function for htab_traverse.
1226 Collect the entry if it matches the regexp. */
1229 collect_matching_scripts (void **slot
, void *info
)
1231 struct loaded_script
*script
= (struct loaded_script
*) *slot
;
1232 struct collect_matching_scripts_data
*data
1233 = (struct collect_matching_scripts_data
*) info
;
1235 if (script
->language
== data
->language
&& re_exec (script
->name
))
1236 VEC_safe_push (loaded_script_ptr
, *data
->scripts_p
, script
);
1244 print_script (struct loaded_script
*script
)
1246 struct ui_out
*uiout
= current_uiout
;
1248 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1250 uiout
->field_string ("loaded", script
->loaded
? "Yes" : "No");
1251 uiout
->field_string ("script", script
->name
);
1254 /* If the name isn't the full path, print it too. */
1255 if (script
->full_path
!= NULL
1256 && strcmp (script
->name
, script
->full_path
) != 0)
1258 uiout
->text ("\tfull name: ");
1259 uiout
->field_string ("full_path", script
->full_path
);
1264 /* Helper for info_auto_load_scripts to sort the scripts by name. */
1267 sort_scripts_by_name (const void *ap
, const void *bp
)
1269 const struct loaded_script
*a
= *(const struct loaded_script
**) ap
;
1270 const struct loaded_script
*b
= *(const struct loaded_script
**) bp
;
1272 return FILENAME_CMP (a
->name
, b
->name
);
1275 /* Special internal GDB value of auto_load_info_scripts's PATTERN identify
1276 the "info auto-load XXX" command has been executed through the general
1277 "info auto-load" invocation. Extra newline will be printed if needed. */
1278 char auto_load_info_scripts_pattern_nl
[] = "";
1280 /* Subroutine of auto_load_info_scripts to simplify it.
1284 print_scripts (VEC (loaded_script_ptr
) *scripts
)
1287 loaded_script_ptr script
;
1289 qsort (VEC_address (loaded_script_ptr
, scripts
),
1290 VEC_length (loaded_script_ptr
, scripts
),
1291 sizeof (loaded_script_ptr
), sort_scripts_by_name
);
1292 for (i
= 0; VEC_iterate (loaded_script_ptr
, scripts
, i
, script
); ++i
)
1293 print_script (script
);
1296 /* Implementation for "info auto-load gdb-scripts"
1297 (and "info auto-load python-scripts"). List scripts in LANGUAGE matching
1298 PATTERN. FROM_TTY is the usual GDB boolean for user interactivity. */
1301 auto_load_info_scripts (char *pattern
, int from_tty
,
1302 const struct extension_language_defn
*language
)
1304 struct ui_out
*uiout
= current_uiout
;
1305 struct auto_load_pspace_info
*pspace_info
;
1306 struct cleanup
*script_chain
;
1307 VEC (loaded_script_ptr
) *script_files
, *script_texts
;
1312 pspace_info
= get_auto_load_pspace_data (current_program_space
);
1314 if (pattern
&& *pattern
)
1316 char *re_err
= re_comp (pattern
);
1319 error (_("Invalid regexp: %s"), re_err
);
1326 /* We need to know the number of rows before we build the table.
1327 Plus we want to sort the scripts by name.
1328 So first traverse the hash table collecting the matching scripts. */
1330 script_files
= VEC_alloc (loaded_script_ptr
, 10);
1331 script_texts
= VEC_alloc (loaded_script_ptr
, 10);
1332 script_chain
= make_cleanup (VEC_cleanup (loaded_script_ptr
), &script_files
);
1333 make_cleanup (VEC_cleanup (loaded_script_ptr
), &script_texts
);
1335 if (pspace_info
!= NULL
&& pspace_info
->loaded_script_files
!= NULL
)
1337 struct collect_matching_scripts_data data
= { &script_files
, language
};
1339 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
1340 htab_traverse_noresize (pspace_info
->loaded_script_files
,
1341 collect_matching_scripts
, &data
);
1344 if (pspace_info
!= NULL
&& pspace_info
->loaded_script_texts
!= NULL
)
1346 struct collect_matching_scripts_data data
= { &script_texts
, language
};
1348 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
1349 htab_traverse_noresize (pspace_info
->loaded_script_texts
,
1350 collect_matching_scripts
, &data
);
1353 nr_scripts
= (VEC_length (loaded_script_ptr
, script_files
)
1354 + VEC_length (loaded_script_ptr
, script_texts
));
1356 /* Table header shifted right by preceding "gdb-scripts: " would not match
1358 if (nr_scripts
> 0 && pattern
== auto_load_info_scripts_pattern_nl
)
1362 ui_out_emit_table
table_emitter (uiout
, 2, nr_scripts
,
1363 "AutoLoadedScriptsTable");
1365 uiout
->table_header (7, ui_left
, "loaded", "Loaded");
1366 uiout
->table_header (70, ui_left
, "script", "Script");
1367 uiout
->table_body ();
1369 print_scripts (script_files
);
1370 print_scripts (script_texts
);
1373 do_cleanups (script_chain
);
1375 if (nr_scripts
== 0)
1377 if (pattern
&& *pattern
)
1378 uiout
->message ("No auto-load scripts matching %s.\n", pattern
);
1380 uiout
->message ("No auto-load scripts.\n");
1384 /* Wrapper for "info auto-load gdb-scripts". */
1387 info_auto_load_gdb_scripts (char *pattern
, int from_tty
)
1389 auto_load_info_scripts (pattern
, from_tty
, &extension_language_gdb
);
1392 /* Implement 'info auto-load local-gdbinit'. */
1395 info_auto_load_local_gdbinit (char *args
, int from_tty
)
1397 if (auto_load_local_gdbinit_pathname
== NULL
)
1398 printf_filtered (_("Local .gdbinit file was not found.\n"));
1399 else if (auto_load_local_gdbinit_loaded
)
1400 printf_filtered (_("Local .gdbinit file \"%s\" has been loaded.\n"),
1401 auto_load_local_gdbinit_pathname
);
1403 printf_filtered (_("Local .gdbinit file \"%s\" has not been loaded.\n"),
1404 auto_load_local_gdbinit_pathname
);
1407 /* Print an "unsupported script" warning if it has not already been printed.
1408 The script is in language LANGUAGE at offset OFFSET in section SECTION_NAME
1412 maybe_print_unsupported_script_warning
1413 (struct auto_load_pspace_info
*pspace_info
,
1414 struct objfile
*objfile
, const struct extension_language_defn
*language
,
1415 const char *section_name
, unsigned offset
)
1417 if (!pspace_info
->unsupported_script_warning_printed
)
1420 Unsupported auto-load script at offset %u in section %s\n\
1422 Use `info auto-load %s-scripts [REGEXP]' to list them."),
1423 offset
, section_name
, objfile_name (objfile
),
1424 ext_lang_name (language
));
1425 pspace_info
->unsupported_script_warning_printed
= 1;
1429 /* Return non-zero if SCRIPT_NOT_FOUND_WARNING_PRINTED of PSPACE_INFO was unset
1430 before calling this function. Always set SCRIPT_NOT_FOUND_WARNING_PRINTED
1434 maybe_print_script_not_found_warning
1435 (struct auto_load_pspace_info
*pspace_info
,
1436 struct objfile
*objfile
, const struct extension_language_defn
*language
,
1437 const char *section_name
, unsigned offset
)
1439 if (!pspace_info
->script_not_found_warning_printed
)
1442 Missing auto-load script at offset %u in section %s\n\
1444 Use `info auto-load %s-scripts [REGEXP]' to list them."),
1445 offset
, section_name
, objfile_name (objfile
),
1446 ext_lang_name (language
));
1447 pspace_info
->script_not_found_warning_printed
= 1;
1451 /* The only valid "set auto-load" argument is off|0|no|disable. */
1454 set_auto_load_cmd (char *args
, int from_tty
)
1456 struct cmd_list_element
*list
;
1459 /* See parse_binary_operation in use by the sub-commands. */
1461 length
= args
? strlen (args
) : 0;
1463 while (length
> 0 && (args
[length
- 1] == ' ' || args
[length
- 1] == '\t'))
1466 if (length
== 0 || (strncmp (args
, "off", length
) != 0
1467 && strncmp (args
, "0", length
) != 0
1468 && strncmp (args
, "no", length
) != 0
1469 && strncmp (args
, "disable", length
) != 0))
1470 error (_("Valid is only global 'set auto-load no'; "
1471 "otherwise check the auto-load sub-commands."));
1473 for (list
= *auto_load_set_cmdlist_get (); list
!= NULL
; list
= list
->next
)
1474 if (list
->var_type
== var_boolean
)
1476 gdb_assert (list
->type
== set_cmd
);
1477 do_set_command (args
, from_tty
, list
);
1481 /* Initialize "set auto-load " commands prefix and return it. */
1483 struct cmd_list_element
**
1484 auto_load_set_cmdlist_get (void)
1486 static struct cmd_list_element
*retval
;
1489 add_prefix_cmd ("auto-load", class_maintenance
, set_auto_load_cmd
, _("\
1490 Auto-loading specific settings.\n\
1491 Configure various auto-load-specific variables such as\n\
1492 automatic loading of Python scripts."),
1493 &retval
, "set auto-load ",
1494 1/*allow-unknown*/, &setlist
);
1499 /* Command "show auto-load" displays summary of all the current
1500 "show auto-load " settings. */
1503 show_auto_load_cmd (char *args
, int from_tty
)
1505 cmd_show_list (*auto_load_show_cmdlist_get (), from_tty
, "");
1508 /* Initialize "show auto-load " commands prefix and return it. */
1510 struct cmd_list_element
**
1511 auto_load_show_cmdlist_get (void)
1513 static struct cmd_list_element
*retval
;
1516 add_prefix_cmd ("auto-load", class_maintenance
, show_auto_load_cmd
, _("\
1517 Show auto-loading specific settings.\n\
1518 Show configuration of various auto-load-specific variables such as\n\
1519 automatic loading of Python scripts."),
1520 &retval
, "show auto-load ",
1521 0/*allow-unknown*/, &showlist
);
1526 /* Command "info auto-load" displays whether the various auto-load files have
1527 been loaded. This is reimplementation of cmd_show_list which inserts
1528 newlines at proper places. */
1531 info_auto_load_cmd (char *args
, int from_tty
)
1533 struct cmd_list_element
*list
;
1534 struct cleanup
*infolist_chain
;
1535 struct ui_out
*uiout
= current_uiout
;
1537 ui_out_emit_tuple
tuple_emitter (uiout
, "infolist");
1539 for (list
= *auto_load_info_cmdlist_get (); list
!= NULL
; list
= list
->next
)
1541 ui_out_emit_tuple
option_emitter (uiout
, "option");
1543 gdb_assert (!list
->prefixlist
);
1544 gdb_assert (list
->type
== not_set_cmd
);
1546 uiout
->field_string ("name", list
->name
);
1548 cmd_func (list
, auto_load_info_scripts_pattern_nl
, from_tty
);
1552 /* Initialize "info auto-load " commands prefix and return it. */
1554 struct cmd_list_element
**
1555 auto_load_info_cmdlist_get (void)
1557 static struct cmd_list_element
*retval
;
1560 add_prefix_cmd ("auto-load", class_info
, info_auto_load_cmd
, _("\
1561 Print current status of auto-loaded files.\n\
1562 Print whether various files like Python scripts or .gdbinit files have been\n\
1563 found and/or loaded."),
1564 &retval
, "info auto-load ",
1565 0/*allow-unknown*/, &infolist
);
1571 _initialize_auto_load (void)
1573 struct cmd_list_element
*cmd
;
1574 char *scripts_directory_help
, *gdb_name_help
, *python_name_help
;
1575 char *guile_name_help
;
1578 auto_load_pspace_data
1579 = register_program_space_data_with_cleanup (NULL
,
1580 auto_load_pspace_data_cleanup
);
1582 observer_attach_new_objfile (auto_load_new_objfile
);
1584 add_setshow_boolean_cmd ("gdb-scripts", class_support
,
1585 &auto_load_gdb_scripts
, _("\
1586 Enable or disable auto-loading of canned sequences of commands scripts."), _("\
1587 Show whether auto-loading of canned sequences of commands scripts is enabled."),
1589 If enabled, canned sequences of commands are loaded when the debugger reads\n\
1590 an executable or shared library.\n\
1591 This options has security implications for untrusted inferiors."),
1592 NULL
, show_auto_load_gdb_scripts
,
1593 auto_load_set_cmdlist_get (),
1594 auto_load_show_cmdlist_get ());
1596 add_cmd ("gdb-scripts", class_info
, info_auto_load_gdb_scripts
,
1597 _("Print the list of automatically loaded sequences of commands.\n\
1598 Usage: info auto-load gdb-scripts [REGEXP]"),
1599 auto_load_info_cmdlist_get ());
1601 add_setshow_boolean_cmd ("local-gdbinit", class_support
,
1602 &auto_load_local_gdbinit
, _("\
1603 Enable or disable auto-loading of .gdbinit script in current directory."), _("\
1604 Show whether auto-loading .gdbinit script in current directory is enabled."),
1606 If enabled, canned sequences of commands are loaded when debugger starts\n\
1607 from .gdbinit file in current directory. Such files are deprecated,\n\
1608 use a script associated with inferior executable file instead.\n\
1609 This options has security implications for untrusted inferiors."),
1610 NULL
, show_auto_load_local_gdbinit
,
1611 auto_load_set_cmdlist_get (),
1612 auto_load_show_cmdlist_get ());
1614 add_cmd ("local-gdbinit", class_info
, info_auto_load_local_gdbinit
,
1615 _("Print whether current directory .gdbinit file has been loaded.\n\
1616 Usage: info auto-load local-gdbinit"),
1617 auto_load_info_cmdlist_get ());
1619 auto_load_dir
= xstrdup (AUTO_LOAD_DIR
);
1621 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GDB
));
1624 GDB scripts: OBJFILE%s\n"),
1626 python_name_help
= NULL
;
1628 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_PYTHON
));
1631 Python scripts: OBJFILE%s\n"),
1634 guile_name_help
= NULL
;
1636 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GUILE
));
1639 Guile scripts: OBJFILE%s\n"),
1642 scripts_directory_help
1644 Automatically loaded scripts are located in one of the directories listed\n\
1650 This option is ignored for the kinds of scripts \
1651 having 'set auto-load ... off'.\n\
1652 Directories listed here need to be present also \
1653 in the 'set auto-load safe-path'\n\
1656 python_name_help
? python_name_help
: "",
1657 guile_name_help
? guile_name_help
: "");
1659 add_setshow_optional_filename_cmd ("scripts-directory", class_support
,
1660 &auto_load_dir
, _("\
1661 Set the list of directories from which to load auto-loaded scripts."), _("\
1662 Show the list of directories from which to load auto-loaded scripts."),
1663 scripts_directory_help
,
1664 set_auto_load_dir
, show_auto_load_dir
,
1665 auto_load_set_cmdlist_get (),
1666 auto_load_show_cmdlist_get ());
1667 xfree (scripts_directory_help
);
1668 xfree (python_name_help
);
1669 xfree (gdb_name_help
);
1670 xfree (guile_name_help
);
1672 auto_load_safe_path
= xstrdup (AUTO_LOAD_SAFE_PATH
);
1673 auto_load_safe_path_vec_update ();
1674 add_setshow_optional_filename_cmd ("safe-path", class_support
,
1675 &auto_load_safe_path
, _("\
1676 Set the list of files and directories that are safe for auto-loading."), _("\
1677 Show the list of files and directories that are safe for auto-loading."), _("\
1678 Various files loaded automatically for the 'set auto-load ...' options must\n\
1679 be located in one of the directories listed by this option. Warning will be\n\
1680 printed and file will not be used otherwise.\n\
1681 You can mix both directory and filename entries.\n\
1682 Setting this parameter to an empty list resets it to its default value.\n\
1683 Setting this parameter to '/' (without the quotes) allows any file\n\
1684 for the 'set auto-load ...' options. Each path entry can be also shell\n\
1685 wildcard pattern; '*' does not match directory separator.\n\
1686 This option is ignored for the kinds of files having 'set auto-load ... off'.\n\
1687 This options has security implications for untrusted inferiors."),
1688 set_auto_load_safe_path
,
1689 show_auto_load_safe_path
,
1690 auto_load_set_cmdlist_get (),
1691 auto_load_show_cmdlist_get ());
1692 observer_attach_gdb_datadir_changed (auto_load_gdb_datadir_changed
);
1694 cmd
= add_cmd ("add-auto-load-safe-path", class_support
,
1695 add_auto_load_safe_path
,
1696 _("Add entries to the list of directories from which it is safe "
1697 "to auto-load files.\n\
1698 See the commands 'set auto-load safe-path' and 'show auto-load safe-path' to\n\
1699 access the current full list setting."),
1701 set_cmd_completer (cmd
, filename_completer
);
1703 cmd
= add_cmd ("add-auto-load-scripts-directory", class_support
,
1705 _("Add entries to the list of directories from which to load "
1706 "auto-loaded scripts.\n\
1707 See the commands 'set auto-load scripts-directory' and\n\
1708 'show auto-load scripts-directory' to access the current full list setting."),
1710 set_cmd_completer (cmd
, filename_completer
);
1712 add_setshow_boolean_cmd ("auto-load", class_maintenance
,
1713 &debug_auto_load
, _("\
1714 Set auto-load verifications debugging."), _("\
1715 Show auto-load verifications debugging."), _("\
1716 When non-zero, debugging output for files of 'set auto-load ...'\n\
1718 NULL
, show_debug_auto_load
,
1719 &setdebuglist
, &showdebuglist
);