1 /* GDB routines for supporting auto-loaded scripts.
3 Copyright (C) 2012 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/>. */
21 #include "auto-load.h"
22 #include "progspace.h"
23 #include "python/python.h"
24 #include "gdb_regex.h"
26 #include "filenames.h"
30 #include "exceptions.h"
31 #include "cli/cli-script.h"
33 #include "cli/cli-decode.h"
34 #include "cli/cli-setshow.h"
36 #include "readline/tilde.h"
37 #include "completer.h"
40 /* The suffix of per-objfile scripts to auto-load as non-Python command files.
41 E.g. When the program loads libfoo.so, look for libfoo-gdb.gdb. */
42 #define GDB_AUTO_FILE_NAME "-gdb.gdb"
44 static void source_gdb_script_for_objfile (struct objfile
*objfile
, FILE *file
,
45 const char *filename
);
47 /* Value of the 'set debug auto-load' configuration variable. */
48 static int debug_auto_load
= 0;
50 /* "show" command for the debug_auto_load configuration variable. */
53 show_debug_auto_load (struct ui_file
*file
, int from_tty
,
54 struct cmd_list_element
*c
, const char *value
)
56 fprintf_filtered (file
, _("Debugging output for files "
57 "of 'set auto-load ...' is %s.\n"),
61 /* User-settable option to enable/disable auto-loading of GDB_AUTO_FILE_NAME
63 set auto-load gdb-scripts on|off
64 This is true if we should auto-load associated scripts when an objfile
65 is opened, false otherwise. */
66 static int auto_load_gdb_scripts
= 1;
68 /* "show" command for the auto_load_gdb_scripts configuration variable. */
71 show_auto_load_gdb_scripts (struct ui_file
*file
, int from_tty
,
72 struct cmd_list_element
*c
, const char *value
)
74 fprintf_filtered (file
, _("Auto-loading of canned sequences of commands "
79 /* Internal-use flag to enable/disable auto-loading.
80 This is true if we should auto-load python code when an objfile is opened,
83 Both auto_load_scripts && global_auto_load must be true to enable
86 This flag exists to facilitate deferring auto-loading during start-up
87 until after ./.gdbinit has been read; it may augment the search directories
88 used to find the scripts. */
89 int global_auto_load
= 1;
91 /* Auto-load .gdbinit file from the current directory? */
92 int auto_load_local_gdbinit
= 1;
94 /* Absolute pathname to the current directory .gdbinit, if it exists. */
95 char *auto_load_local_gdbinit_pathname
= NULL
;
97 /* Boolean value if AUTO_LOAD_LOCAL_GDBINIT_PATHNAME has been loaded. */
98 int auto_load_local_gdbinit_loaded
= 0;
100 /* "show" command for the auto_load_local_gdbinit configuration variable. */
103 show_auto_load_local_gdbinit (struct ui_file
*file
, int from_tty
,
104 struct cmd_list_element
*c
, const char *value
)
106 fprintf_filtered (file
, _("Auto-loading of .gdbinit script from current "
107 "directory is %s.\n"),
111 /* Directory list from which to load auto-loaded scripts. It is not checked
112 for absolute paths but they are strongly recommended. It is initialized by
113 _initialize_auto_load. */
114 static char *auto_load_dir
;
116 /* "set" command for the auto_load_dir configuration variable. */
119 set_auto_load_dir (char *args
, int from_tty
, struct cmd_list_element
*c
)
121 /* Setting the variable to "" resets it to the compile time defaults. */
122 if (auto_load_dir
[0] == '\0')
124 xfree (auto_load_dir
);
125 auto_load_dir
= xstrdup (AUTO_LOAD_DIR
);
129 /* "show" command for the auto_load_dir configuration variable. */
132 show_auto_load_dir (struct ui_file
*file
, int from_tty
,
133 struct cmd_list_element
*c
, const char *value
)
135 fprintf_filtered (file
, _("List of directories from which to load "
136 "auto-loaded scripts is %s.\n"),
140 /* Directory list safe to hold auto-loaded files. It is not checked for
141 absolute paths but they are strongly recommended. It is initialized by
142 _initialize_auto_load. */
143 static char *auto_load_safe_path
;
145 /* Vector of directory elements of AUTO_LOAD_SAFE_PATH with each one normalized
146 by tilde_expand and possibly each entries has added its gdb_realpath
148 static VEC (char_ptr
) *auto_load_safe_path_vec
;
150 /* Update auto_load_safe_path_vec from current AUTO_LOAD_SAFE_PATH. */
153 auto_load_safe_path_vec_update (void)
155 VEC (char_ptr
) *dir_vec
= NULL
;
160 fprintf_unfiltered (gdb_stdlog
,
161 _("auto-load: Updating directories of \"%s\".\n"),
162 auto_load_safe_path
);
164 free_char_ptr_vec (auto_load_safe_path_vec
);
166 auto_load_safe_path_vec
= dirnames_to_char_ptr_vec (auto_load_safe_path
);
167 len
= VEC_length (char_ptr
, auto_load_safe_path_vec
);
169 /* Apply tilde_expand and gdb_realpath to each AUTO_LOAD_SAFE_PATH_VEC
171 for (ix
= 0; ix
< len
; ix
++)
173 char *dir
= VEC_index (char_ptr
, auto_load_safe_path_vec
, ix
);
174 char *ddir_subst
, *expanded
, *real_path
;
176 ddir_subst
= xstrdup (dir
);
177 substitute_path_component (&ddir_subst
, "$ddir", gdb_datadir
);
178 expanded
= tilde_expand (ddir_subst
);
180 real_path
= gdb_realpath (expanded
);
182 /* Ensure the current entry is at least a valid path (therefore
183 $ddir-expanded and tilde-expanded). */
184 VEC_replace (char_ptr
, auto_load_safe_path_vec
, ix
, expanded
);
188 if (strcmp (expanded
, dir
) == 0)
189 fprintf_unfiltered (gdb_stdlog
,
190 _("auto-load: Using directory \"%s\".\n"),
193 fprintf_unfiltered (gdb_stdlog
,
194 _("auto-load: Resolved directory \"%s\" "
200 /* If gdb_realpath returns a different content, append it. */
201 if (strcmp (real_path
, expanded
) == 0)
205 VEC_safe_push (char_ptr
, auto_load_safe_path_vec
, real_path
);
208 fprintf_unfiltered (gdb_stdlog
,
209 _("auto-load: And canonicalized as \"%s\".\n"),
215 /* Variable gdb_datadir has been set. Update content depending on $ddir. */
218 auto_load_gdb_datadir_changed (void)
220 auto_load_safe_path_vec_update ();
223 /* "set" command for the auto_load_safe_path configuration variable. */
226 set_auto_load_safe_path (char *args
, int from_tty
, struct cmd_list_element
*c
)
228 /* Setting the variable to "" resets it to the compile time defaults. */
229 if (auto_load_safe_path
[0] == '\0')
231 xfree (auto_load_safe_path
);
232 auto_load_safe_path
= xstrdup (AUTO_LOAD_SAFE_PATH
);
235 auto_load_safe_path_vec_update ();
238 /* "show" command for the auto_load_safe_path configuration variable. */
241 show_auto_load_safe_path (struct ui_file
*file
, int from_tty
,
242 struct cmd_list_element
*c
, const char *value
)
244 if (strcmp (value
, "/") == 0)
245 fprintf_filtered (file
, _("Auto-load files are safe to load from any "
248 fprintf_filtered (file
, _("List of directories from which it is safe to "
249 "auto-load files is %s.\n"),
253 /* "add-auto-load-safe-path" command for the auto_load_safe_path configuration
257 add_auto_load_safe_path (char *args
, int from_tty
)
261 if (args
== NULL
|| *args
== 0)
263 Directory argument required.\n\
264 Use 'set auto-load safe-path /' for disabling the auto-load safe-path security.\
267 s
= xstrprintf ("%s%c%s", auto_load_safe_path
, DIRNAME_SEPARATOR
, args
);
268 xfree (auto_load_safe_path
);
269 auto_load_safe_path
= s
;
271 auto_load_safe_path_vec_update ();
274 /* Return 1 if FILENAME is equal to DIR or if FILENAME belongs to the
275 subdirectory DIR. Return 0 otherwise. gdb_realpath normalization is never
278 static ATTRIBUTE_PURE
int
279 filename_is_in_dir (const char *filename
, const char *dir
)
281 size_t dir_len
= strlen (dir
);
283 while (dir_len
&& IS_DIR_SEPARATOR (dir
[dir_len
- 1]))
286 /* Ensure auto_load_safe_path "/" matches any FILENAME. On MS-Windows
287 platform FILENAME even after gdb_realpath does not have to start with
288 IS_DIR_SEPARATOR character, such as the 'C:\x.exe' filename. */
292 return (filename_ncmp (dir
, filename
, dir_len
) == 0
293 && (IS_DIR_SEPARATOR (filename
[dir_len
])
294 || filename
[dir_len
] == '\0'));
297 /* Return 1 if FILENAME belongs to one of directory components of
298 AUTO_LOAD_SAFE_PATH_VEC. Return 0 otherwise.
299 auto_load_safe_path_vec_update is never called.
300 *FILENAME_REALP may be updated by gdb_realpath of FILENAME - it has to be
301 freed by the caller. */
304 filename_is_in_auto_load_safe_path_vec (const char *filename
,
305 char **filename_realp
)
310 for (ix
= 0; VEC_iterate (char_ptr
, auto_load_safe_path_vec
, ix
, dir
); ++ix
)
311 if (*filename_realp
== NULL
&& filename_is_in_dir (filename
, dir
))
316 if (*filename_realp
== NULL
)
318 *filename_realp
= gdb_realpath (filename
);
319 if (debug_auto_load
&& strcmp (*filename_realp
, filename
) != 0)
320 fprintf_unfiltered (gdb_stdlog
,
321 _("auto-load: Resolved "
322 "file \"%s\" as \"%s\".\n"),
323 filename
, *filename_realp
);
326 if (strcmp (*filename_realp
, filename
) != 0)
327 for (ix
= 0; VEC_iterate (char_ptr
, auto_load_safe_path_vec
, ix
, dir
);
329 if (filename_is_in_dir (*filename_realp
, dir
))
336 fprintf_unfiltered (gdb_stdlog
, _("auto-load: File \"%s\" matches "
337 "directory \"%s\".\n"),
345 /* Return 1 if FILENAME is located in one of the directories of
346 AUTO_LOAD_SAFE_PATH. Otherwise call warning and return 0. FILENAME does
347 not have to be an absolute path.
349 Existence of FILENAME is not checked. Function will still give a warning
350 even if the caller would quietly skip non-existing file in unsafe
354 file_is_auto_load_safe (const char *filename
, const char *debug_fmt
, ...)
356 char *filename_real
= NULL
;
357 struct cleanup
*back_to
;
363 va_start (debug_args
, debug_fmt
);
364 vfprintf_unfiltered (gdb_stdlog
, debug_fmt
, debug_args
);
368 back_to
= make_cleanup (free_current_contents
, &filename_real
);
370 if (filename_is_in_auto_load_safe_path_vec (filename
, &filename_real
))
372 do_cleanups (back_to
);
376 auto_load_safe_path_vec_update ();
377 if (filename_is_in_auto_load_safe_path_vec (filename
, &filename_real
))
379 do_cleanups (back_to
);
383 warning (_("File \"%s\" auto-loading has been declined by your "
384 "`auto-load safe-path' set to \"%s\"."),
385 filename_real
, auto_load_safe_path
);
387 do_cleanups (back_to
);
391 /* Definition of script language for GDB canned sequences of commands. */
393 static const struct script_language script_language_gdb
394 = { GDB_AUTO_FILE_NAME
, source_gdb_script_for_objfile
};
397 source_gdb_script_for_objfile (struct objfile
*objfile
, FILE *file
,
398 const char *filename
)
401 struct auto_load_pspace_info
*pspace_info
;
402 volatile struct gdb_exception e
;
404 is_safe
= file_is_auto_load_safe (filename
, _("auto-load: Loading canned "
405 "sequences of commands script "
406 "\"%s\" for objfile \"%s\".\n"),
407 filename
, objfile
->name
);
409 /* Add this script to the hash table too so "info auto-load gdb-scripts"
411 pspace_info
= get_auto_load_pspace_data_for_loading (current_program_space
);
412 maybe_add_script (pspace_info
, is_safe
, filename
, filename
,
413 &script_language_gdb
);
418 TRY_CATCH (e
, RETURN_MASK_ALL
)
420 script_from_file (file
, filename
);
422 exception_print (gdb_stderr
, e
);
425 /* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
426 the same script. There's no point in loading the script multiple times,
427 and there can be a lot of objfiles and scripts, so we keep track of scripts
430 struct auto_load_pspace_info
432 /* For each program space we keep track of loaded scripts. */
433 struct htab
*loaded_scripts
;
435 /* Non-zero if we've issued the warning about an auto-load script not being
436 found. We only want to issue this warning once. */
437 int script_not_found_warning_printed
;
440 /* Objects of this type are stored in the loaded script hash table. */
444 /* Name as provided by the objfile. */
447 /* Full path name or NULL if script wasn't found (or was otherwise
449 const char *full_path
;
451 /* Non-zero if this script has been loaded. */
454 const struct script_language
*language
;
457 /* Per-program-space data key. */
458 static const struct program_space_data
*auto_load_pspace_data
;
461 auto_load_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
463 struct auto_load_pspace_info
*info
;
465 info
= program_space_data (pspace
, auto_load_pspace_data
);
468 if (info
->loaded_scripts
)
469 htab_delete (info
->loaded_scripts
);
474 /* Get the current autoload data. If none is found yet, add it now. This
475 function always returns a valid object. */
477 static struct auto_load_pspace_info
*
478 get_auto_load_pspace_data (struct program_space
*pspace
)
480 struct auto_load_pspace_info
*info
;
482 info
= program_space_data (pspace
, auto_load_pspace_data
);
485 info
= XZALLOC (struct auto_load_pspace_info
);
486 set_program_space_data (pspace
, auto_load_pspace_data
, info
);
492 /* Hash function for the loaded script hash. */
495 hash_loaded_script_entry (const void *data
)
497 const struct loaded_script
*e
= data
;
499 return htab_hash_string (e
->name
) ^ htab_hash_pointer (e
->language
);
502 /* Equality function for the loaded script hash. */
505 eq_loaded_script_entry (const void *a
, const void *b
)
507 const struct loaded_script
*ea
= a
;
508 const struct loaded_script
*eb
= b
;
510 return strcmp (ea
->name
, eb
->name
) == 0 && ea
->language
== eb
->language
;
513 /* Initialize the table to track loaded scripts.
514 Each entry is hashed by the full path name. */
517 init_loaded_scripts_info (struct auto_load_pspace_info
*pspace_info
)
519 /* Choose 31 as the starting size of the hash table, somewhat arbitrarily.
520 Space for each entry is obtained with one malloc so we can free them
523 pspace_info
->loaded_scripts
= htab_create (31,
524 hash_loaded_script_entry
,
525 eq_loaded_script_entry
,
528 pspace_info
->script_not_found_warning_printed
= FALSE
;
531 /* Wrapper on get_auto_load_pspace_data to also allocate the hash table
532 for loading scripts. */
534 struct auto_load_pspace_info
*
535 get_auto_load_pspace_data_for_loading (struct program_space
*pspace
)
537 struct auto_load_pspace_info
*info
;
539 info
= get_auto_load_pspace_data (pspace
);
540 if (info
->loaded_scripts
== NULL
)
541 init_loaded_scripts_info (info
);
546 /* Add script NAME in LANGUAGE to hash table of PSPACE_INFO. LOADED 1 if the
547 script has been (is going to) be loaded, 0 otherwise (such as if it has not
548 been found). FULL_PATH is NULL if the script wasn't found. The result is
549 true if the script was already in the hash table. */
552 maybe_add_script (struct auto_load_pspace_info
*pspace_info
, int loaded
,
553 const char *name
, const char *full_path
,
554 const struct script_language
*language
)
556 struct htab
*htab
= pspace_info
->loaded_scripts
;
557 struct loaded_script
**slot
, entry
;
561 entry
.language
= language
;
562 slot
= (struct loaded_script
**) htab_find_slot (htab
, &entry
, INSERT
);
563 in_hash_table
= *slot
!= NULL
;
565 /* If this script is not in the hash table, add it. */
571 /* Allocate all space in one chunk so it's easier to free. */
572 *slot
= xmalloc (sizeof (**slot
)
574 + (full_path
!= NULL
? (strlen (full_path
) + 1) : 0));
575 p
= ((char*) *slot
) + sizeof (**slot
);
578 if (full_path
!= NULL
)
581 strcpy (p
, full_path
);
582 (*slot
)->full_path
= p
;
585 (*slot
)->full_path
= NULL
;
586 (*slot
)->loaded
= loaded
;
587 (*slot
)->language
= language
;
590 return in_hash_table
;
593 /* Clear the table of loaded section scripts. */
596 clear_section_scripts (void)
598 struct program_space
*pspace
= current_program_space
;
599 struct auto_load_pspace_info
*info
;
601 info
= program_space_data (pspace
, auto_load_pspace_data
);
602 if (info
!= NULL
&& info
->loaded_scripts
!= NULL
)
604 htab_delete (info
->loaded_scripts
);
605 info
->loaded_scripts
= NULL
;
606 info
->script_not_found_warning_printed
= FALSE
;
610 /* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
614 auto_load_objfile_script (struct objfile
*objfile
,
615 const struct script_language
*language
)
618 char *filename
, *debugfile
;
621 struct cleanup
*cleanups
;
623 realname
= gdb_realpath (objfile
->name
);
624 len
= strlen (realname
);
625 filename
= xmalloc (len
+ strlen (language
->suffix
) + 1);
626 memcpy (filename
, realname
, len
);
627 strcpy (filename
+ len
, language
->suffix
);
629 cleanups
= make_cleanup (xfree
, filename
);
630 make_cleanup (xfree
, realname
);
632 input
= fopen (filename
, "r");
633 debugfile
= filename
;
635 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Attempted file \"%s\" %s.\n"),
636 debugfile
, input
? _("exists") : _("does not exist"));
641 VEC (char_ptr
) *debugdir_vec
;
644 debugdir_vec
= dirnames_to_char_ptr_vec (debug_file_directory
);
645 make_cleanup_free_char_ptr_vec (debugdir_vec
);
648 fprintf_unfiltered (gdb_stdlog
,
649 _("auto-load: Searching 'set debug-file-directory' "
651 debug_file_directory
);
653 for (ix
= 0; VEC_iterate (char_ptr
, debugdir_vec
, ix
, debugdir
); ++ix
)
655 /* Also try the same file in the separate debug info directory. */
656 debugfile
= xmalloc (strlen (debugdir
) + strlen (filename
) + 1);
657 strcpy (debugfile
, debugdir
);
659 /* FILENAME is absolute, so we don't need a "/" here. */
660 strcat (debugfile
, filename
);
662 make_cleanup (xfree
, debugfile
);
663 input
= fopen (debugfile
, "r");
665 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Attempted file "
668 input
? _("exists") : _("does not exist"));
680 /* Also try the same file in a subdirectory of gdb's data
683 vec
= dirnames_to_char_ptr_vec (auto_load_dir
);
684 make_cleanup_free_char_ptr_vec (vec
);
687 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Searching 'set auto-load "
688 "scripts-directory' path \"%s\".\n"),
691 for (ix
= 0; VEC_iterate (char_ptr
, vec
, ix
, dir
); ++ix
)
693 debugfile
= xstrdup (dir
);
694 substitute_path_component (&debugfile
, "$ddir", gdb_datadir
);
695 debugfile
= xrealloc (debugfile
, (strlen (debugfile
)
696 + strlen (filename
) + 1));
698 /* FILENAME is absolute, so we don't need a "/" here. */
699 strcat (debugfile
, filename
);
701 make_cleanup (xfree
, debugfile
);
702 input
= fopen (debugfile
, "r");
704 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Attempted file "
707 input
? _("exists") : _("does not exist"));
715 make_cleanup_fclose (input
);
717 /* To preserve existing behaviour we don't check for whether the
718 script was already in the table, and always load it.
719 It's highly unlikely that we'd ever load it twice,
720 and these scripts are required to be idempotent under multiple
722 language
->source_script_for_objfile (objfile
, input
, debugfile
);
725 do_cleanups (cleanups
);
728 /* Load any auto-loaded scripts for OBJFILE. */
731 load_auto_scripts_for_objfile (struct objfile
*objfile
)
733 if (!global_auto_load
)
736 if (auto_load_gdb_scripts
)
737 auto_load_objfile_script (objfile
, &script_language_gdb
);
739 gdbpy_load_auto_scripts_for_objfile (objfile
);
742 /* This is a new_objfile observer callback to auto-load scripts.
744 Two flavors of auto-loaded scripts are supported.
745 1) based on the path to the objfile
746 2) from .debug_gdb_scripts section */
749 auto_load_new_objfile (struct objfile
*objfile
)
753 /* OBJFILE is NULL when loading a new "main" symbol-file. */
754 clear_section_scripts ();
758 load_auto_scripts_for_objfile (objfile
);
761 /* Collect scripts to be printed in a vec. */
763 typedef struct loaded_script
*loaded_script_ptr
;
764 DEF_VEC_P (loaded_script_ptr
);
766 struct collect_matching_scripts_data
768 VEC (loaded_script_ptr
) **scripts_p
;
770 const struct script_language
*language
;
773 /* Traversal function for htab_traverse.
774 Collect the entry if it matches the regexp. */
777 collect_matching_scripts (void **slot
, void *info
)
779 struct loaded_script
*script
= *slot
;
780 struct collect_matching_scripts_data
*data
= info
;
782 if (script
->language
== data
->language
&& re_exec (script
->name
))
783 VEC_safe_push (loaded_script_ptr
, *data
->scripts_p
, script
);
791 print_script (struct loaded_script
*script
)
793 struct ui_out
*uiout
= current_uiout
;
794 struct cleanup
*chain
;
796 chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
798 ui_out_field_string (uiout
, "loaded", script
->loaded
? "Yes" : "No");
799 ui_out_field_string (uiout
, "script", script
->name
);
800 ui_out_text (uiout
, "\n");
802 /* If the name isn't the full path, print it too. */
803 if (script
->full_path
!= NULL
804 && strcmp (script
->name
, script
->full_path
) != 0)
806 ui_out_text (uiout
, "\tfull name: ");
807 ui_out_field_string (uiout
, "full_path", script
->full_path
);
808 ui_out_text (uiout
, "\n");
814 /* Helper for info_auto_load_scripts to sort the scripts by name. */
817 sort_scripts_by_name (const void *ap
, const void *bp
)
819 const struct loaded_script
*a
= *(const struct loaded_script
**) ap
;
820 const struct loaded_script
*b
= *(const struct loaded_script
**) bp
;
822 return FILENAME_CMP (a
->name
, b
->name
);
825 /* Special internal GDB value of auto_load_info_scripts's PATTERN identify
826 the "info auto-load XXX" command has been executed through the general
827 "info auto-load" invocation. Extra newline will be printed if needed. */
828 char auto_load_info_scripts_pattern_nl
[] = "";
830 /* Implementation for "info auto-load gdb-scripts"
831 (and "info auto-load python-scripts"). List scripts in LANGUAGE matching
832 PATTERN. FROM_TTY is the usual GDB boolean for user interactivity. */
835 auto_load_info_scripts (char *pattern
, int from_tty
,
836 const struct script_language
*language
)
838 struct ui_out
*uiout
= current_uiout
;
839 struct auto_load_pspace_info
*pspace_info
;
840 struct cleanup
*script_chain
;
841 VEC (loaded_script_ptr
) *scripts
;
846 pspace_info
= get_auto_load_pspace_data (current_program_space
);
848 if (pattern
&& *pattern
)
850 char *re_err
= re_comp (pattern
);
853 error (_("Invalid regexp: %s"), re_err
);
860 /* We need to know the number of rows before we build the table.
861 Plus we want to sort the scripts by name.
862 So first traverse the hash table collecting the matching scripts. */
864 scripts
= VEC_alloc (loaded_script_ptr
, 10);
865 script_chain
= make_cleanup (VEC_cleanup (loaded_script_ptr
), &scripts
);
867 if (pspace_info
!= NULL
&& pspace_info
->loaded_scripts
!= NULL
)
869 struct collect_matching_scripts_data data
= { &scripts
, language
};
872 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
873 htab_traverse_noresize (pspace_info
->loaded_scripts
,
874 collect_matching_scripts
, &data
);
878 nr_scripts
= VEC_length (loaded_script_ptr
, scripts
);
880 /* Table header shifted right by preceding "gdb-scripts: " would not match
882 if (nr_scripts
> 0 && pattern
== auto_load_info_scripts_pattern_nl
)
883 ui_out_text (uiout
, "\n");
885 make_cleanup_ui_out_table_begin_end (uiout
, 2, nr_scripts
,
886 "AutoLoadedScriptsTable");
888 ui_out_table_header (uiout
, 7, ui_left
, "loaded", "Loaded");
889 ui_out_table_header (uiout
, 70, ui_left
, "script", "Script");
890 ui_out_table_body (uiout
);
895 loaded_script_ptr script
;
897 qsort (VEC_address (loaded_script_ptr
, scripts
),
898 VEC_length (loaded_script_ptr
, scripts
),
899 sizeof (loaded_script_ptr
), sort_scripts_by_name
);
900 for (i
= 0; VEC_iterate (loaded_script_ptr
, scripts
, i
, script
); ++i
)
901 print_script (script
);
904 do_cleanups (script_chain
);
908 if (pattern
&& *pattern
)
909 ui_out_message (uiout
, 0, "No auto-load scripts matching %s.\n",
912 ui_out_message (uiout
, 0, "No auto-load scripts.\n");
916 /* Wrapper for "info auto-load gdb-scripts". */
919 info_auto_load_gdb_scripts (char *pattern
, int from_tty
)
921 auto_load_info_scripts (pattern
, from_tty
, &script_language_gdb
);
924 /* Implement 'info auto-load local-gdbinit'. */
927 info_auto_load_local_gdbinit (char *args
, int from_tty
)
929 if (auto_load_local_gdbinit_pathname
== NULL
)
930 printf_filtered (_("Local .gdbinit file was not found.\n"));
931 else if (auto_load_local_gdbinit_loaded
)
932 printf_filtered (_("Local .gdbinit file \"%s\" has been loaded.\n"),
933 auto_load_local_gdbinit_pathname
);
935 printf_filtered (_("Local .gdbinit file \"%s\" has not been loaded.\n"),
936 auto_load_local_gdbinit_pathname
);
939 /* Return non-zero if SCRIPT_NOT_FOUND_WARNING_PRINTED of PSPACE_INFO was unset
940 before calling this function. Always set SCRIPT_NOT_FOUND_WARNING_PRINTED
944 script_not_found_warning_print (struct auto_load_pspace_info
*pspace_info
)
946 int retval
= !pspace_info
->script_not_found_warning_printed
;
948 pspace_info
->script_not_found_warning_printed
= 1;
953 /* The only valid "set auto-load" argument is off|0|no|disable. */
956 set_auto_load_cmd (char *args
, int from_tty
)
958 struct cmd_list_element
*list
;
961 /* See parse_binary_operation in use by the sub-commands. */
963 length
= args
? strlen (args
) : 0;
965 while (length
> 0 && (args
[length
- 1] == ' ' || args
[length
- 1] == '\t'))
968 if (length
== 0 || (strncmp (args
, "off", length
) != 0
969 && strncmp (args
, "0", length
) != 0
970 && strncmp (args
, "no", length
) != 0
971 && strncmp (args
, "disable", length
) != 0))
972 error (_("Valid is only global 'set auto-load no'; "
973 "otherwise check the auto-load sub-commands."));
975 for (list
= *auto_load_set_cmdlist_get (); list
!= NULL
; list
= list
->next
)
976 if (list
->var_type
== var_boolean
)
978 gdb_assert (list
->type
== set_cmd
);
979 do_setshow_command (args
, from_tty
, list
);
983 /* Initialize "set auto-load " commands prefix and return it. */
985 struct cmd_list_element
**
986 auto_load_set_cmdlist_get (void)
988 static struct cmd_list_element
*retval
;
991 add_prefix_cmd ("auto-load", class_maintenance
, set_auto_load_cmd
, _("\
992 Auto-loading specific settings.\n\
993 Configure various auto-load-specific variables such as\n\
994 automatic loading of Python scripts."),
995 &retval
, "set auto-load ",
996 1/*allow-unknown*/, &setlist
);
1001 /* Command "show auto-load" displays summary of all the current
1002 "show auto-load " settings. */
1005 show_auto_load_cmd (char *args
, int from_tty
)
1007 cmd_show_list (*auto_load_show_cmdlist_get (), from_tty
, "");
1010 /* Initialize "show auto-load " commands prefix and return it. */
1012 struct cmd_list_element
**
1013 auto_load_show_cmdlist_get (void)
1015 static struct cmd_list_element
*retval
;
1018 add_prefix_cmd ("auto-load", class_maintenance
, show_auto_load_cmd
, _("\
1019 Show auto-loading specific settings.\n\
1020 Show configuration of various auto-load-specific variables such as\n\
1021 automatic loading of Python scripts."),
1022 &retval
, "show auto-load ",
1023 0/*allow-unknown*/, &showlist
);
1028 /* Command "info auto-load" displays whether the various auto-load files have
1029 been loaded. This is reimplementation of cmd_show_list which inserts
1030 newlines at proper places. */
1033 info_auto_load_cmd (char *args
, int from_tty
)
1035 struct cmd_list_element
*list
;
1036 struct cleanup
*infolist_chain
;
1037 struct ui_out
*uiout
= current_uiout
;
1039 infolist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "infolist");
1041 for (list
= *auto_load_info_cmdlist_get (); list
!= NULL
; list
= list
->next
)
1043 struct cleanup
*option_chain
1044 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
1046 gdb_assert (!list
->prefixlist
);
1047 gdb_assert (list
->type
== not_set_cmd
);
1049 ui_out_field_string (uiout
, "name", list
->name
);
1050 ui_out_text (uiout
, ": ");
1051 cmd_func (list
, auto_load_info_scripts_pattern_nl
, from_tty
);
1053 /* Close the tuple. */
1054 do_cleanups (option_chain
);
1057 /* Close the tuple. */
1058 do_cleanups (infolist_chain
);
1061 /* Initialize "info auto-load " commands prefix and return it. */
1063 struct cmd_list_element
**
1064 auto_load_info_cmdlist_get (void)
1066 static struct cmd_list_element
*retval
;
1069 add_prefix_cmd ("auto-load", class_info
, info_auto_load_cmd
, _("\
1070 Print current status of auto-loaded files.\n\
1071 Print whether various files like Python scripts or .gdbinit files have been\n\
1072 found and/or loaded."),
1073 &retval
, "info auto-load ",
1074 0/*allow-unknown*/, &infolist
);
1079 void _initialize_auto_load (void);
1082 _initialize_auto_load (void)
1084 struct cmd_list_element
*cmd
;
1086 auto_load_pspace_data
1087 = register_program_space_data_with_cleanup (auto_load_pspace_data_cleanup
);
1089 observer_attach_new_objfile (auto_load_new_objfile
);
1091 add_setshow_boolean_cmd ("gdb-scripts", class_support
,
1092 &auto_load_gdb_scripts
, _("\
1093 Enable or disable auto-loading of canned sequences of commands scripts."), _("\
1094 Show whether auto-loading of canned sequences of commands scripts is enabled."),
1096 If enabled, canned sequences of commands are loaded when the debugger reads\n\
1097 an executable or shared library.\n\
1098 This options has security implications for untrusted inferiors."),
1099 NULL
, show_auto_load_gdb_scripts
,
1100 auto_load_set_cmdlist_get (),
1101 auto_load_show_cmdlist_get ());
1103 add_cmd ("gdb-scripts", class_info
, info_auto_load_gdb_scripts
,
1104 _("Print the list of automatically loaded sequences of commands.\n\
1105 Usage: info auto-load gdb-scripts [REGEXP]"),
1106 auto_load_info_cmdlist_get ());
1108 add_setshow_boolean_cmd ("local-gdbinit", class_support
,
1109 &auto_load_local_gdbinit
, _("\
1110 Enable or disable auto-loading of .gdbinit script in current directory."), _("\
1111 Show whether auto-loading .gdbinit script in current directory is enabled."),
1113 If enabled, canned sequences of commands are loaded when debugger starts\n\
1114 from .gdbinit file in current directory. Such files are deprecated,\n\
1115 use a script associated with inferior executable file instead.\n\
1116 This options has security implications for untrusted inferiors."),
1117 NULL
, show_auto_load_local_gdbinit
,
1118 auto_load_set_cmdlist_get (),
1119 auto_load_show_cmdlist_get ());
1121 add_cmd ("local-gdbinit", class_info
, info_auto_load_local_gdbinit
,
1122 _("Print whether current directory .gdbinit file has been loaded.\n\
1123 Usage: info auto-load local-gdbinit"),
1124 auto_load_info_cmdlist_get ());
1126 auto_load_dir
= xstrdup (AUTO_LOAD_DIR
);
1127 add_setshow_optional_filename_cmd ("scripts-directory", class_support
,
1128 &auto_load_dir
, _("\
1129 Set the list of directories from which to load auto-loaded scripts."), _("\
1130 Show the list of directories from which to load auto-loaded scripts."), _("\
1131 Automatically loaded Python scripts and GDB scripts are located in one of the\n\
1132 directories listed by this option. This option is ignored for the kinds of\n\
1133 scripts having 'set auto-load ... off'. Directories listed here need to be\n\
1134 present also in the 'set auto-load safe-path' option."),
1135 set_auto_load_dir
, show_auto_load_dir
,
1136 auto_load_set_cmdlist_get (),
1137 auto_load_show_cmdlist_get ());
1139 auto_load_safe_path
= xstrdup (AUTO_LOAD_SAFE_PATH
);
1140 auto_load_safe_path_vec_update ();
1141 add_setshow_optional_filename_cmd ("safe-path", class_support
,
1142 &auto_load_safe_path
, _("\
1143 Set the list of directories from which it is safe to auto-load files."), _("\
1144 Show the list of directories from which it is safe to auto-load files."), _("\
1145 Various files loaded automatically for the 'set auto-load ...' options must\n\
1146 be located in one of the directories listed by this option. Warning will be\n\
1147 printed and file will not be used otherwise.\n\
1148 Setting this parameter to an empty list resets it to its default value.\n\
1149 Setting this parameter to '/' (without the quotes) allows any file\n\
1150 for the 'set auto-load ...' options.\n\
1151 This option is ignored for the kinds of files having 'set auto-load ... off'.\n\
1152 This options has security implications for untrusted inferiors."),
1153 set_auto_load_safe_path
,
1154 show_auto_load_safe_path
,
1155 auto_load_set_cmdlist_get (),
1156 auto_load_show_cmdlist_get ());
1157 observer_attach_gdb_datadir_changed (auto_load_gdb_datadir_changed
);
1159 cmd
= add_cmd ("add-auto-load-safe-path", class_support
,
1160 add_auto_load_safe_path
,
1161 _("Add entries to the list of directories from which it is safe "
1162 "to auto-load files.\n\
1163 See the commands 'set auto-load safe-path' and 'show auto-load safe-path' to\n\
1164 access the current full list setting."),
1166 set_cmd_completer (cmd
, filename_completer
);
1168 add_setshow_boolean_cmd ("auto-load", class_maintenance
,
1169 &debug_auto_load
, _("\
1170 Set auto-load verifications debugging."), _("\
1171 Show auto-load verifications debugging."), _("\
1172 When non-zero, debugging output for files of 'set auto-load ...'\n\
1174 NULL
, show_debug_auto_load
,
1175 &setdebuglist
, &showdebuglist
);