1 /* GDB routines for supporting auto-loaded scripts.
3 Copyright (C) 2012-2015 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 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
, expanded
) == 0)
245 VEC_safe_push (char_ptr
, auto_load_safe_path_vec
, real_path
);
248 fprintf_unfiltered (gdb_stdlog
,
249 _("auto-load: And canonicalized as \"%s\".\n"),
255 /* Variable gdb_datadir has been set. Update content depending on $datadir. */
258 auto_load_gdb_datadir_changed (void)
260 auto_load_safe_path_vec_update ();
263 /* "set" command for the auto_load_safe_path configuration variable. */
266 set_auto_load_safe_path (char *args
, 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 (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 (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
= alloca (strlen (filename
) + 1);
412 strcpy (filename_copy
, filename
);
413 pattern_copy
= 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 - it has to be
423 freed by the caller. */
426 filename_is_in_auto_load_safe_path_vec (const char *filename
,
427 char **filename_realp
)
432 for (ix
= 0; VEC_iterate (char_ptr
, auto_load_safe_path_vec
, ix
, pattern
);
434 if (*filename_realp
== NULL
&& filename_is_in_pattern (filename
, pattern
))
439 if (*filename_realp
== NULL
)
441 *filename_realp
= gdb_realpath (filename
);
442 if (debug_auto_load
&& strcmp (*filename_realp
, filename
) != 0)
443 fprintf_unfiltered (gdb_stdlog
,
444 _("auto-load: Resolved "
445 "file \"%s\" as \"%s\".\n"),
446 filename
, *filename_realp
);
449 if (strcmp (*filename_realp
, filename
) != 0)
451 VEC_iterate (char_ptr
, auto_load_safe_path_vec
, ix
, pattern
); ++ix
)
452 if (filename_is_in_pattern (*filename_realp
, pattern
))
459 fprintf_unfiltered (gdb_stdlog
, _("auto-load: File \"%s\" matches "
460 "directory \"%s\".\n"),
468 /* Return 1 if FILENAME is located in one of the directories of
469 AUTO_LOAD_SAFE_PATH. Otherwise call warning and return 0. FILENAME does
470 not have to be an absolute path.
472 Existence of FILENAME is not checked. Function will still give a warning
473 even if the caller would quietly skip non-existing file in unsafe
477 file_is_auto_load_safe (const char *filename
, const char *debug_fmt
, ...)
479 char *filename_real
= NULL
;
480 struct cleanup
*back_to
;
481 static int advice_printed
= 0;
487 va_start (debug_args
, debug_fmt
);
488 vfprintf_unfiltered (gdb_stdlog
, debug_fmt
, debug_args
);
492 back_to
= make_cleanup (free_current_contents
, &filename_real
);
494 if (filename_is_in_auto_load_safe_path_vec (filename
, &filename_real
))
496 do_cleanups (back_to
);
500 auto_load_safe_path_vec_update ();
501 if (filename_is_in_auto_load_safe_path_vec (filename
, &filename_real
))
503 do_cleanups (back_to
);
507 warning (_("File \"%s\" auto-loading has been declined by your "
508 "`auto-load safe-path' set to \"%s\"."),
509 filename_real
, auto_load_safe_path
);
513 const char *homedir
= getenv ("HOME");
518 homeinit
= xstrprintf ("%s/%s", homedir
, gdbinit
);
519 make_cleanup (xfree
, homeinit
);
521 printf_filtered (_("\
522 To enable execution of this file add\n\
523 \tadd-auto-load-safe-path %s\n\
524 line to your configuration file \"%s\".\n\
525 To completely disable this security protection add\n\
526 \tset auto-load safe-path /\n\
527 line to your configuration file \"%s\".\n\
528 For more information about this security protection see the\n\
529 \"Auto-loading safe path\" section in the GDB manual. E.g., run from the shell:\n\
530 \tinfo \"(gdb)Auto-loading safe path\"\n"),
531 filename_real
, homeinit
, homeinit
);
535 do_cleanups (back_to
);
539 /* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
540 the same script. There's no point in loading the script multiple times,
541 and there can be a lot of objfiles and scripts, so we keep track of scripts
544 struct auto_load_pspace_info
546 /* For each program space we keep track of loaded scripts, both when
547 specified as file names and as scripts to be executed directly. */
548 struct htab
*loaded_script_files
;
549 struct htab
*loaded_script_texts
;
551 /* Non-zero if we've issued the warning about an auto-load script not being
552 supported. We only want to issue this warning once. */
553 int unsupported_script_warning_printed
;
555 /* Non-zero if we've issued the warning about an auto-load script not being
556 found. We only want to issue this warning once. */
557 int script_not_found_warning_printed
;
560 /* Objects of this type are stored in the loaded_script hash table. */
564 /* Name as provided by the objfile. */
567 /* Full path name or NULL if script wasn't found (or was otherwise
568 inaccessible), or NULL for loaded_script_texts. */
569 const char *full_path
;
571 /* Non-zero if this script has been loaded. */
574 const struct extension_language_defn
*language
;
577 /* Per-program-space data key. */
578 static const struct program_space_data
*auto_load_pspace_data
;
581 auto_load_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
583 struct auto_load_pspace_info
*info
= arg
;
585 if (info
->loaded_script_files
)
586 htab_delete (info
->loaded_script_files
);
587 if (info
->loaded_script_texts
)
588 htab_delete (info
->loaded_script_texts
);
592 /* Get the current autoload data. If none is found yet, add it now. This
593 function always returns a valid object. */
595 static struct auto_load_pspace_info
*
596 get_auto_load_pspace_data (struct program_space
*pspace
)
598 struct auto_load_pspace_info
*info
;
600 info
= program_space_data (pspace
, auto_load_pspace_data
);
603 info
= XCNEW (struct auto_load_pspace_info
);
604 set_program_space_data (pspace
, auto_load_pspace_data
, info
);
610 /* Hash function for the loaded script hash. */
613 hash_loaded_script_entry (const void *data
)
615 const struct loaded_script
*e
= data
;
617 return htab_hash_string (e
->name
) ^ htab_hash_pointer (e
->language
);
620 /* Equality function for the loaded script hash. */
623 eq_loaded_script_entry (const void *a
, const void *b
)
625 const struct loaded_script
*ea
= a
;
626 const struct loaded_script
*eb
= b
;
628 return strcmp (ea
->name
, eb
->name
) == 0 && ea
->language
== eb
->language
;
631 /* Initialize the table to track loaded scripts.
632 Each entry is hashed by the full path name. */
635 init_loaded_scripts_info (struct auto_load_pspace_info
*pspace_info
)
637 /* Choose 31 as the starting size of the hash table, somewhat arbitrarily.
638 Space for each entry is obtained with one malloc so we can free them
641 pspace_info
->loaded_script_files
= htab_create (31,
642 hash_loaded_script_entry
,
643 eq_loaded_script_entry
,
645 pspace_info
->loaded_script_texts
= htab_create (31,
646 hash_loaded_script_entry
,
647 eq_loaded_script_entry
,
650 pspace_info
->unsupported_script_warning_printed
= FALSE
;
651 pspace_info
->script_not_found_warning_printed
= FALSE
;
654 /* Wrapper on get_auto_load_pspace_data to also allocate the hash table
655 for loading scripts. */
657 struct auto_load_pspace_info
*
658 get_auto_load_pspace_data_for_loading (struct program_space
*pspace
)
660 struct auto_load_pspace_info
*info
;
662 info
= get_auto_load_pspace_data (pspace
);
663 if (info
->loaded_script_files
== NULL
)
664 init_loaded_scripts_info (info
);
669 /* Add script file NAME in LANGUAGE to hash table of PSPACE_INFO.
670 LOADED 1 if the script has been (is going to) be loaded, 0 otherwise
671 (such as if it has not been found).
672 FULL_PATH is NULL if the script wasn't found.
673 The result is true if the script was already in the hash table. */
676 maybe_add_script_file (struct auto_load_pspace_info
*pspace_info
, int loaded
,
677 const char *name
, const char *full_path
,
678 const struct extension_language_defn
*language
)
680 struct htab
*htab
= pspace_info
->loaded_script_files
;
681 struct loaded_script
**slot
, entry
;
685 entry
.language
= language
;
686 slot
= (struct loaded_script
**) htab_find_slot (htab
, &entry
, INSERT
);
687 in_hash_table
= *slot
!= NULL
;
689 /* If this script is not in the hash table, add it. */
695 /* Allocate all space in one chunk so it's easier to free. */
696 *slot
= xmalloc (sizeof (**slot
)
698 + (full_path
!= NULL
? (strlen (full_path
) + 1) : 0));
699 p
= ((char*) *slot
) + sizeof (**slot
);
702 if (full_path
!= NULL
)
705 strcpy (p
, full_path
);
706 (*slot
)->full_path
= p
;
709 (*slot
)->full_path
= NULL
;
710 (*slot
)->loaded
= loaded
;
711 (*slot
)->language
= language
;
714 return in_hash_table
;
717 /* Add script contents NAME in LANGUAGE to hash table of PSPACE_INFO.
718 LOADED 1 if the script has been (is going to) be loaded, 0 otherwise
719 (such as if it has not been found).
720 The result is true if the script was already in the hash table. */
723 maybe_add_script_text (struct auto_load_pspace_info
*pspace_info
,
724 int loaded
, const char *name
,
725 const struct extension_language_defn
*language
)
727 struct htab
*htab
= pspace_info
->loaded_script_texts
;
728 struct loaded_script
**slot
, entry
;
732 entry
.language
= language
;
733 slot
= (struct loaded_script
**) htab_find_slot (htab
, &entry
, INSERT
);
734 in_hash_table
= *slot
!= NULL
;
736 /* If this script is not in the hash table, add it. */
742 /* Allocate all space in one chunk so it's easier to free. */
743 *slot
= xmalloc (sizeof (**slot
) + strlen (name
) + 1);
744 p
= ((char*) *slot
) + sizeof (**slot
);
747 (*slot
)->full_path
= NULL
;
748 (*slot
)->loaded
= loaded
;
749 (*slot
)->language
= language
;
752 return in_hash_table
;
755 /* Clear the table of loaded section scripts. */
758 clear_section_scripts (void)
760 struct program_space
*pspace
= current_program_space
;
761 struct auto_load_pspace_info
*info
;
763 info
= program_space_data (pspace
, auto_load_pspace_data
);
764 if (info
!= NULL
&& info
->loaded_script_files
!= NULL
)
766 htab_delete (info
->loaded_script_files
);
767 htab_delete (info
->loaded_script_texts
);
768 info
->loaded_script_files
= NULL
;
769 info
->loaded_script_texts
= NULL
;
770 info
->unsupported_script_warning_printed
= FALSE
;
771 info
->script_not_found_warning_printed
= FALSE
;
775 /* Look for the auto-load script in LANGUAGE associated with OBJFILE where
776 OBJFILE's gdb_realpath is REALNAME and load it. Return 1 if we found any
777 matching script, return 0 otherwise. */
780 auto_load_objfile_script_1 (struct objfile
*objfile
, const char *realname
,
781 const struct extension_language_defn
*language
)
783 char *filename
, *debugfile
;
786 struct cleanup
*cleanups
;
787 const char *suffix
= ext_lang_auto_load_suffix (language
);
789 len
= strlen (realname
);
790 filename
= xmalloc (len
+ strlen (suffix
) + 1);
791 memcpy (filename
, realname
, len
);
792 strcpy (filename
+ len
, suffix
);
794 cleanups
= make_cleanup (xfree
, filename
);
796 input
= gdb_fopen_cloexec (filename
, "r");
797 debugfile
= filename
;
799 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Attempted file \"%s\" %s.\n"),
800 debugfile
, input
? _("exists") : _("does not exist"));
808 /* Also try the same file in a subdirectory of gdb's data
811 vec
= auto_load_expand_dir_vars (auto_load_dir
);
812 make_cleanup_free_char_ptr_vec (vec
);
815 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Searching 'set auto-load "
816 "scripts-directory' path \"%s\".\n"),
819 for (ix
= 0; VEC_iterate (char_ptr
, vec
, ix
, dir
); ++ix
)
821 debugfile
= xmalloc (strlen (dir
) + strlen (filename
) + 1);
822 strcpy (debugfile
, dir
);
824 /* FILENAME is absolute, so we don't need a "/" here. */
825 strcat (debugfile
, filename
);
827 make_cleanup (xfree
, debugfile
);
828 input
= gdb_fopen_cloexec (debugfile
, "r");
830 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Attempted file "
833 input
? _("exists") : _("does not exist"));
842 struct auto_load_pspace_info
*pspace_info
;
844 make_cleanup_fclose (input
);
847 = file_is_auto_load_safe (debugfile
,
848 _("auto-load: Loading %s script \"%s\""
849 " by extension for objfile \"%s\".\n"),
850 ext_lang_name (language
),
851 debugfile
, objfile_name (objfile
));
853 /* Add this script to the hash table too so
854 "info auto-load ${lang}-scripts" can print it. */
856 = get_auto_load_pspace_data_for_loading (current_program_space
);
857 maybe_add_script_file (pspace_info
, is_safe
, debugfile
, debugfile
,
860 /* To preserve existing behaviour we don't check for whether the
861 script was already in the table, and always load it.
862 It's highly unlikely that we'd ever load it twice,
863 and these scripts are required to be idempotent under multiple
867 objfile_script_sourcer_func
*sourcer
868 = ext_lang_objfile_script_sourcer (language
);
870 /* We shouldn't get here if support for the language isn't
871 compiled in. And the extension language is required to implement
873 gdb_assert (sourcer
!= NULL
);
874 sourcer (language
, objfile
, input
, debugfile
);
882 do_cleanups (cleanups
);
886 /* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
890 auto_load_objfile_script (struct objfile
*objfile
,
891 const struct extension_language_defn
*language
)
893 char *realname
= gdb_realpath (objfile_name (objfile
));
894 struct cleanup
*cleanups
= make_cleanup (xfree
, realname
);
896 if (!auto_load_objfile_script_1 (objfile
, realname
, language
))
898 /* For Windows/DOS .exe executables, strip the .exe suffix, so that
899 FOO-gdb.gdb could be used for FOO.exe, and try again. */
901 size_t len
= strlen (realname
);
902 const size_t lexe
= sizeof (".exe") - 1;
904 if (len
> lexe
&& strcasecmp (realname
+ len
- lexe
, ".exe") == 0)
907 realname
[len
] = '\0';
909 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Stripped .exe suffix, "
910 "retrying with \"%s\".\n"),
912 auto_load_objfile_script_1 (objfile
, realname
, language
);
916 do_cleanups (cleanups
);
919 /* Subroutine of source_section_scripts to simplify it.
920 Load FILE as a script in extension language LANGUAGE.
921 The script is from section SECTION_NAME in OBJFILE at offset OFFSET. */
924 source_script_file (struct auto_load_pspace_info
*pspace_info
,
925 struct objfile
*objfile
,
926 const struct extension_language_defn
*language
,
927 const char *section_name
, unsigned int offset
,
932 int opened
, in_hash_table
;
933 struct cleanup
*cleanups
;
934 objfile_script_sourcer_func
*sourcer
;
936 /* Skip this script if support is not compiled in. */
937 sourcer
= ext_lang_objfile_script_sourcer (language
);
940 /* We don't throw an error, the program is still debuggable. */
941 maybe_print_unsupported_script_warning (pspace_info
, objfile
, language
,
942 section_name
, offset
);
943 /* We *could* still try to open it, but there's no point. */
944 maybe_add_script_file (pspace_info
, 0, file
, NULL
, language
);
948 /* Skip this script if auto-loading it has been disabled. */
949 if (!ext_lang_auto_load_enabled (language
))
951 /* No message is printed, just skip it. */
955 opened
= find_and_open_script (file
, 1 /*search_path*/,
956 &stream
, &full_path
);
958 cleanups
= make_cleanup (null_cleanup
, NULL
);
961 make_cleanup_fclose (stream
);
962 make_cleanup (xfree
, full_path
);
964 if (!file_is_auto_load_safe (full_path
,
965 _("auto-load: Loading %s script "
966 "\"%s\" from section \"%s\" of "
967 "objfile \"%s\".\n"),
968 ext_lang_name (language
), full_path
,
969 section_name
, objfile_name (objfile
)))
976 /* If one script isn't found it's not uncommon for more to not be
977 found either. We don't want to print a message for each script,
978 too much noise. Instead, we print the warning once and tell the
979 user how to find the list of scripts that weren't loaded.
980 We don't throw an error, the program is still debuggable.
982 IWBN if complaints.c were more general-purpose. */
984 maybe_print_script_not_found_warning (pspace_info
, objfile
, language
,
985 section_name
, offset
);
988 in_hash_table
= maybe_add_script_file (pspace_info
, opened
, file
, full_path
,
991 /* If this file is not currently loaded, load it. */
992 if (opened
&& !in_hash_table
)
993 sourcer (language
, objfile
, stream
, full_path
);
995 do_cleanups (cleanups
);
998 /* Subroutine of source_section_scripts to simplify it.
999 Execute SCRIPT as a script in extension language LANG.
1000 The script is from section SECTION_NAME in OBJFILE at offset OFFSET. */
1003 execute_script_contents (struct auto_load_pspace_info
*pspace_info
,
1004 struct objfile
*objfile
,
1005 const struct extension_language_defn
*language
,
1006 const char *section_name
, unsigned int offset
,
1009 objfile_script_executor_func
*executor
;
1010 const char *newline
, *script_text
;
1012 int is_safe
, in_hash_table
;
1013 struct cleanup
*cleanups
;
1015 cleanups
= make_cleanup (null_cleanup
, NULL
);
1017 /* The first line of the script is the name of the script.
1018 It must not contain any kind of space character. */
1020 newline
= strchr (script
, '\n');
1021 if (newline
!= NULL
)
1025 /* Put the name in a buffer and validate it. */
1026 buf
= xstrndup (script
, newline
- script
);
1027 make_cleanup (xfree
, buf
);
1028 for (p
= buf
; *p
!= '\0'; ++p
)
1033 /* We don't allow nameless scripts, they're not helpful to the user. */
1034 if (p
!= buf
&& *p
== '\0')
1039 /* We don't throw an error, the program is still debuggable. */
1041 Missing/bad script name in entry at offset %u in section %s\n\
1043 offset
, section_name
, objfile_name (objfile
));
1044 do_cleanups (cleanups
);
1047 script_text
= newline
+ 1;
1049 /* Skip this script if support is not compiled in. */
1050 executor
= ext_lang_objfile_script_executor (language
);
1051 if (executor
== NULL
)
1053 /* We don't throw an error, the program is still debuggable. */
1054 maybe_print_unsupported_script_warning (pspace_info
, objfile
, language
,
1055 section_name
, offset
);
1056 maybe_add_script_text (pspace_info
, 0, name
, language
);
1057 do_cleanups (cleanups
);
1061 /* Skip this script if auto-loading it has been disabled. */
1062 if (!ext_lang_auto_load_enabled (language
))
1064 /* No message is printed, just skip it. */
1065 do_cleanups (cleanups
);
1069 is_safe
= file_is_auto_load_safe (objfile_name (objfile
),
1070 _("auto-load: Loading %s script "
1071 "\"%s\" from section \"%s\" of "
1072 "objfile \"%s\".\n"),
1073 ext_lang_name (language
), name
,
1074 section_name
, objfile_name (objfile
));
1076 in_hash_table
= maybe_add_script_text (pspace_info
, is_safe
, name
, language
);
1078 /* If this file is not currently loaded, load it. */
1079 if (is_safe
&& !in_hash_table
)
1080 executor (language
, objfile
, name
, script_text
);
1082 do_cleanups (cleanups
);
1085 /* Load scripts specified in OBJFILE.
1086 START,END delimit a buffer containing a list of nul-terminated
1088 SECTION_NAME is used in error messages.
1090 Scripts specified as file names are found per normal "source -s" command
1091 processing. First the script is looked for in $cwd. If not found there
1092 the source search path is used.
1094 The section contains a list of path names of script files to load or
1095 actual script contents. Each entry is nul-terminated. */
1098 source_section_scripts (struct objfile
*objfile
, const char *section_name
,
1099 const char *start
, const char *end
)
1102 struct auto_load_pspace_info
*pspace_info
;
1104 pspace_info
= get_auto_load_pspace_data_for_loading (current_program_space
);
1106 for (p
= start
; p
< end
; ++p
)
1109 const struct extension_language_defn
*language
;
1110 unsigned int offset
= p
- start
;
1115 case SECTION_SCRIPT_ID_PYTHON_FILE
:
1116 case SECTION_SCRIPT_ID_PYTHON_TEXT
:
1117 language
= get_ext_lang_defn (EXT_LANG_PYTHON
);
1119 case SECTION_SCRIPT_ID_SCHEME_FILE
:
1120 case SECTION_SCRIPT_ID_SCHEME_TEXT
:
1121 language
= get_ext_lang_defn (EXT_LANG_GUILE
);
1124 warning (_("Invalid entry in %s section"), section_name
);
1125 /* We could try various heuristics to find the next valid entry,
1126 but it's safer to just punt. */
1131 while (p
< end
&& *p
!= '\0')
1135 warning (_("Non-nul-terminated entry in %s at offset %u"),
1136 section_name
, offset
);
1137 /* Don't load/execute it. */
1143 case SECTION_SCRIPT_ID_PYTHON_FILE
:
1144 case SECTION_SCRIPT_ID_SCHEME_FILE
:
1147 warning (_("Empty entry in %s at offset %u"),
1148 section_name
, offset
);
1151 source_script_file (pspace_info
, objfile
, language
,
1152 section_name
, offset
, entry
);
1154 case SECTION_SCRIPT_ID_PYTHON_TEXT
:
1155 case SECTION_SCRIPT_ID_SCHEME_TEXT
:
1156 execute_script_contents (pspace_info
, objfile
, language
,
1157 section_name
, offset
, entry
);
1163 /* Load scripts specified in section SECTION_NAME of OBJFILE. */
1166 auto_load_section_scripts (struct objfile
*objfile
, const char *section_name
)
1168 bfd
*abfd
= objfile
->obfd
;
1169 asection
*scripts_sect
;
1170 bfd_byte
*data
= NULL
;
1172 scripts_sect
= bfd_get_section_by_name (abfd
, section_name
);
1173 if (scripts_sect
== NULL
)
1176 if (!bfd_get_full_section_contents (abfd
, scripts_sect
, &data
))
1177 warning (_("Couldn't read %s section of %s"),
1178 section_name
, bfd_get_filename (abfd
));
1181 struct cleanup
*cleanups
;
1182 char *p
= (char *) data
;
1184 cleanups
= make_cleanup (xfree
, p
);
1185 source_section_scripts (objfile
, section_name
, p
,
1186 p
+ bfd_get_section_size (scripts_sect
));
1187 do_cleanups (cleanups
);
1191 /* Load any auto-loaded scripts for OBJFILE. */
1194 load_auto_scripts_for_objfile (struct objfile
*objfile
)
1196 /* Return immediately if auto-loading has been globally disabled.
1197 This is to handle sequencing of operations during gdb startup.
1198 Also return immediately if OBJFILE was not created from a file
1199 on the local filesystem. */
1200 if (!global_auto_load
1201 || (objfile
->flags
& OBJF_NOT_FILENAME
) != 0
1202 || is_target_filename (objfile
->original_name
))
1205 /* Load any extension language scripts for this objfile.
1206 E.g., foo-gdb.gdb, foo-gdb.py. */
1207 auto_load_ext_lang_scripts_for_objfile (objfile
);
1209 /* Load any scripts mentioned in AUTO_SECTION_NAME (.debug_gdb_scripts). */
1210 auto_load_section_scripts (objfile
, AUTO_SECTION_NAME
);
1213 /* This is a new_objfile observer callback to auto-load scripts.
1215 Two flavors of auto-loaded scripts are supported.
1216 1) based on the path to the objfile
1217 2) from .debug_gdb_scripts section */
1220 auto_load_new_objfile (struct objfile
*objfile
)
1224 /* OBJFILE is NULL when loading a new "main" symbol-file. */
1225 clear_section_scripts ();
1229 load_auto_scripts_for_objfile (objfile
);
1232 /* Collect scripts to be printed in a vec. */
1234 typedef struct loaded_script
*loaded_script_ptr
;
1235 DEF_VEC_P (loaded_script_ptr
);
1237 struct collect_matching_scripts_data
1239 VEC (loaded_script_ptr
) **scripts_p
;
1241 const struct extension_language_defn
*language
;
1244 /* Traversal function for htab_traverse.
1245 Collect the entry if it matches the regexp. */
1248 collect_matching_scripts (void **slot
, void *info
)
1250 struct loaded_script
*script
= *slot
;
1251 struct collect_matching_scripts_data
*data
= info
;
1253 if (script
->language
== data
->language
&& re_exec (script
->name
))
1254 VEC_safe_push (loaded_script_ptr
, *data
->scripts_p
, script
);
1262 print_script (struct loaded_script
*script
)
1264 struct ui_out
*uiout
= current_uiout
;
1265 struct cleanup
*chain
;
1267 chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1269 ui_out_field_string (uiout
, "loaded", script
->loaded
? "Yes" : "No");
1270 ui_out_field_string (uiout
, "script", script
->name
);
1271 ui_out_text (uiout
, "\n");
1273 /* If the name isn't the full path, print it too. */
1274 if (script
->full_path
!= NULL
1275 && strcmp (script
->name
, script
->full_path
) != 0)
1277 ui_out_text (uiout
, "\tfull name: ");
1278 ui_out_field_string (uiout
, "full_path", script
->full_path
);
1279 ui_out_text (uiout
, "\n");
1282 do_cleanups (chain
);
1285 /* Helper for info_auto_load_scripts to sort the scripts by name. */
1288 sort_scripts_by_name (const void *ap
, const void *bp
)
1290 const struct loaded_script
*a
= *(const struct loaded_script
**) ap
;
1291 const struct loaded_script
*b
= *(const struct loaded_script
**) bp
;
1293 return FILENAME_CMP (a
->name
, b
->name
);
1296 /* Special internal GDB value of auto_load_info_scripts's PATTERN identify
1297 the "info auto-load XXX" command has been executed through the general
1298 "info auto-load" invocation. Extra newline will be printed if needed. */
1299 char auto_load_info_scripts_pattern_nl
[] = "";
1301 /* Subroutine of auto_load_info_scripts to simplify it.
1305 print_scripts (VEC (loaded_script_ptr
) *scripts
)
1307 struct ui_out
*uiout
= current_uiout
;
1309 loaded_script_ptr script
;
1311 qsort (VEC_address (loaded_script_ptr
, scripts
),
1312 VEC_length (loaded_script_ptr
, scripts
),
1313 sizeof (loaded_script_ptr
), sort_scripts_by_name
);
1314 for (i
= 0; VEC_iterate (loaded_script_ptr
, scripts
, i
, script
); ++i
)
1315 print_script (script
);
1318 /* Implementation for "info auto-load gdb-scripts"
1319 (and "info auto-load python-scripts"). List scripts in LANGUAGE matching
1320 PATTERN. FROM_TTY is the usual GDB boolean for user interactivity. */
1323 auto_load_info_scripts (char *pattern
, int from_tty
,
1324 const struct extension_language_defn
*language
)
1326 struct ui_out
*uiout
= current_uiout
;
1327 struct auto_load_pspace_info
*pspace_info
;
1328 struct cleanup
*script_chain
;
1329 VEC (loaded_script_ptr
) *script_files
, *script_texts
;
1334 pspace_info
= get_auto_load_pspace_data (current_program_space
);
1336 if (pattern
&& *pattern
)
1338 char *re_err
= re_comp (pattern
);
1341 error (_("Invalid regexp: %s"), re_err
);
1348 /* We need to know the number of rows before we build the table.
1349 Plus we want to sort the scripts by name.
1350 So first traverse the hash table collecting the matching scripts. */
1352 script_files
= VEC_alloc (loaded_script_ptr
, 10);
1353 script_texts
= VEC_alloc (loaded_script_ptr
, 10);
1354 script_chain
= make_cleanup (VEC_cleanup (loaded_script_ptr
), &script_files
);
1355 make_cleanup (VEC_cleanup (loaded_script_ptr
), &script_texts
);
1357 if (pspace_info
!= NULL
&& pspace_info
->loaded_script_files
!= NULL
)
1359 struct collect_matching_scripts_data data
= { &script_files
, language
};
1361 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
1362 htab_traverse_noresize (pspace_info
->loaded_script_files
,
1363 collect_matching_scripts
, &data
);
1366 if (pspace_info
!= NULL
&& pspace_info
->loaded_script_texts
!= NULL
)
1368 struct collect_matching_scripts_data data
= { &script_texts
, language
};
1370 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
1371 htab_traverse_noresize (pspace_info
->loaded_script_texts
,
1372 collect_matching_scripts
, &data
);
1375 nr_scripts
= (VEC_length (loaded_script_ptr
, script_files
)
1376 + VEC_length (loaded_script_ptr
, script_texts
));
1378 /* Table header shifted right by preceding "gdb-scripts: " would not match
1380 if (nr_scripts
> 0 && pattern
== auto_load_info_scripts_pattern_nl
)
1381 ui_out_text (uiout
, "\n");
1383 /* Note: This creates a cleanup to output the table end marker. */
1384 make_cleanup_ui_out_table_begin_end (uiout
, 2, nr_scripts
,
1385 "AutoLoadedScriptsTable");
1387 ui_out_table_header (uiout
, 7, ui_left
, "loaded", "Loaded");
1388 ui_out_table_header (uiout
, 70, ui_left
, "script", "Script");
1389 ui_out_table_body (uiout
);
1391 print_scripts (script_files
);
1392 print_scripts (script_texts
);
1394 /* Finish up the table before checking for no matching scripts. */
1395 do_cleanups (script_chain
);
1397 if (nr_scripts
== 0)
1399 if (pattern
&& *pattern
)
1400 ui_out_message (uiout
, 0, "No auto-load scripts matching %s.\n",
1403 ui_out_message (uiout
, 0, "No auto-load scripts.\n");
1407 /* Wrapper for "info auto-load gdb-scripts". */
1410 info_auto_load_gdb_scripts (char *pattern
, int from_tty
)
1412 auto_load_info_scripts (pattern
, from_tty
, &extension_language_gdb
);
1415 /* Implement 'info auto-load local-gdbinit'. */
1418 info_auto_load_local_gdbinit (char *args
, int from_tty
)
1420 if (auto_load_local_gdbinit_pathname
== NULL
)
1421 printf_filtered (_("Local .gdbinit file was not found.\n"));
1422 else if (auto_load_local_gdbinit_loaded
)
1423 printf_filtered (_("Local .gdbinit file \"%s\" has been loaded.\n"),
1424 auto_load_local_gdbinit_pathname
);
1426 printf_filtered (_("Local .gdbinit file \"%s\" has not been loaded.\n"),
1427 auto_load_local_gdbinit_pathname
);
1430 /* Print an "unsupported script" warning if it has not already been printed.
1431 The script is in language LANGUAGE at offset OFFSET in section SECTION_NAME
1435 maybe_print_unsupported_script_warning
1436 (struct auto_load_pspace_info
*pspace_info
,
1437 struct objfile
*objfile
, const struct extension_language_defn
*language
,
1438 const char *section_name
, unsigned offset
)
1440 if (!pspace_info
->unsupported_script_warning_printed
)
1443 Unsupported auto-load script at offset %u in section %s\n\
1445 Use `info auto-load %s-scripts [REGEXP]' to list them."),
1446 offset
, section_name
, objfile_name (objfile
),
1447 ext_lang_name (language
));
1448 pspace_info
->unsupported_script_warning_printed
= 1;
1452 /* Return non-zero if SCRIPT_NOT_FOUND_WARNING_PRINTED of PSPACE_INFO was unset
1453 before calling this function. Always set SCRIPT_NOT_FOUND_WARNING_PRINTED
1457 maybe_print_script_not_found_warning
1458 (struct auto_load_pspace_info
*pspace_info
,
1459 struct objfile
*objfile
, const struct extension_language_defn
*language
,
1460 const char *section_name
, unsigned offset
)
1462 if (!pspace_info
->script_not_found_warning_printed
)
1465 Missing auto-load script at offset %u in section %s\n\
1467 Use `info auto-load %s-scripts [REGEXP]' to list them."),
1468 offset
, section_name
, objfile_name (objfile
),
1469 ext_lang_name (language
));
1470 pspace_info
->script_not_found_warning_printed
= 1;
1474 /* The only valid "set auto-load" argument is off|0|no|disable. */
1477 set_auto_load_cmd (char *args
, int from_tty
)
1479 struct cmd_list_element
*list
;
1482 /* See parse_binary_operation in use by the sub-commands. */
1484 length
= args
? strlen (args
) : 0;
1486 while (length
> 0 && (args
[length
- 1] == ' ' || args
[length
- 1] == '\t'))
1489 if (length
== 0 || (strncmp (args
, "off", length
) != 0
1490 && strncmp (args
, "0", length
) != 0
1491 && strncmp (args
, "no", length
) != 0
1492 && strncmp (args
, "disable", length
) != 0))
1493 error (_("Valid is only global 'set auto-load no'; "
1494 "otherwise check the auto-load sub-commands."));
1496 for (list
= *auto_load_set_cmdlist_get (); list
!= NULL
; list
= list
->next
)
1497 if (list
->var_type
== var_boolean
)
1499 gdb_assert (list
->type
== set_cmd
);
1500 do_set_command (args
, from_tty
, list
);
1504 /* Initialize "set auto-load " commands prefix and return it. */
1506 struct cmd_list_element
**
1507 auto_load_set_cmdlist_get (void)
1509 static struct cmd_list_element
*retval
;
1512 add_prefix_cmd ("auto-load", class_maintenance
, set_auto_load_cmd
, _("\
1513 Auto-loading specific settings.\n\
1514 Configure various auto-load-specific variables such as\n\
1515 automatic loading of Python scripts."),
1516 &retval
, "set auto-load ",
1517 1/*allow-unknown*/, &setlist
);
1522 /* Command "show auto-load" displays summary of all the current
1523 "show auto-load " settings. */
1526 show_auto_load_cmd (char *args
, int from_tty
)
1528 cmd_show_list (*auto_load_show_cmdlist_get (), from_tty
, "");
1531 /* Initialize "show auto-load " commands prefix and return it. */
1533 struct cmd_list_element
**
1534 auto_load_show_cmdlist_get (void)
1536 static struct cmd_list_element
*retval
;
1539 add_prefix_cmd ("auto-load", class_maintenance
, show_auto_load_cmd
, _("\
1540 Show auto-loading specific settings.\n\
1541 Show configuration of various auto-load-specific variables such as\n\
1542 automatic loading of Python scripts."),
1543 &retval
, "show auto-load ",
1544 0/*allow-unknown*/, &showlist
);
1549 /* Command "info auto-load" displays whether the various auto-load files have
1550 been loaded. This is reimplementation of cmd_show_list which inserts
1551 newlines at proper places. */
1554 info_auto_load_cmd (char *args
, int from_tty
)
1556 struct cmd_list_element
*list
;
1557 struct cleanup
*infolist_chain
;
1558 struct ui_out
*uiout
= current_uiout
;
1560 infolist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "infolist");
1562 for (list
= *auto_load_info_cmdlist_get (); list
!= NULL
; list
= list
->next
)
1564 struct cleanup
*option_chain
1565 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
1567 gdb_assert (!list
->prefixlist
);
1568 gdb_assert (list
->type
== not_set_cmd
);
1570 ui_out_field_string (uiout
, "name", list
->name
);
1571 ui_out_text (uiout
, ": ");
1572 cmd_func (list
, auto_load_info_scripts_pattern_nl
, from_tty
);
1574 /* Close the tuple. */
1575 do_cleanups (option_chain
);
1578 /* Close the tuple. */
1579 do_cleanups (infolist_chain
);
1582 /* Initialize "info auto-load " commands prefix and return it. */
1584 struct cmd_list_element
**
1585 auto_load_info_cmdlist_get (void)
1587 static struct cmd_list_element
*retval
;
1590 add_prefix_cmd ("auto-load", class_info
, info_auto_load_cmd
, _("\
1591 Print current status of auto-loaded files.\n\
1592 Print whether various files like Python scripts or .gdbinit files have been\n\
1593 found and/or loaded."),
1594 &retval
, "info auto-load ",
1595 0/*allow-unknown*/, &infolist
);
1600 void _initialize_auto_load (void);
1603 _initialize_auto_load (void)
1605 struct cmd_list_element
*cmd
;
1606 char *scripts_directory_help
, *gdb_name_help
, *python_name_help
;
1607 char *guile_name_help
;
1610 auto_load_pspace_data
1611 = register_program_space_data_with_cleanup (NULL
,
1612 auto_load_pspace_data_cleanup
);
1614 observer_attach_new_objfile (auto_load_new_objfile
);
1616 add_setshow_boolean_cmd ("gdb-scripts", class_support
,
1617 &auto_load_gdb_scripts
, _("\
1618 Enable or disable auto-loading of canned sequences of commands scripts."), _("\
1619 Show whether auto-loading of canned sequences of commands scripts is enabled."),
1621 If enabled, canned sequences of commands are loaded when the debugger reads\n\
1622 an executable or shared library.\n\
1623 This options has security implications for untrusted inferiors."),
1624 NULL
, show_auto_load_gdb_scripts
,
1625 auto_load_set_cmdlist_get (),
1626 auto_load_show_cmdlist_get ());
1628 add_cmd ("gdb-scripts", class_info
, info_auto_load_gdb_scripts
,
1629 _("Print the list of automatically loaded sequences of commands.\n\
1630 Usage: info auto-load gdb-scripts [REGEXP]"),
1631 auto_load_info_cmdlist_get ());
1633 add_setshow_boolean_cmd ("local-gdbinit", class_support
,
1634 &auto_load_local_gdbinit
, _("\
1635 Enable or disable auto-loading of .gdbinit script in current directory."), _("\
1636 Show whether auto-loading .gdbinit script in current directory is enabled."),
1638 If enabled, canned sequences of commands are loaded when debugger starts\n\
1639 from .gdbinit file in current directory. Such files are deprecated,\n\
1640 use a script associated with inferior executable file instead.\n\
1641 This options has security implications for untrusted inferiors."),
1642 NULL
, show_auto_load_local_gdbinit
,
1643 auto_load_set_cmdlist_get (),
1644 auto_load_show_cmdlist_get ());
1646 add_cmd ("local-gdbinit", class_info
, info_auto_load_local_gdbinit
,
1647 _("Print whether current directory .gdbinit file has been loaded.\n\
1648 Usage: info auto-load local-gdbinit"),
1649 auto_load_info_cmdlist_get ());
1651 auto_load_dir
= xstrdup (AUTO_LOAD_DIR
);
1653 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GDB
));
1656 GDB scripts: OBJFILE%s\n"),
1658 python_name_help
= NULL
;
1660 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_PYTHON
));
1663 Python scripts: OBJFILE%s\n"),
1666 guile_name_help
= NULL
;
1668 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GUILE
));
1671 Guile scripts: OBJFILE%s\n"),
1674 scripts_directory_help
1676 Automatically loaded scripts are located in one of the directories listed\n\
1682 This option is ignored for the kinds of scripts \
1683 having 'set auto-load ... off'.\n\
1684 Directories listed here need to be present also \
1685 in the 'set auto-load safe-path'\n\
1688 python_name_help
? python_name_help
: "",
1689 guile_name_help
? guile_name_help
: "");
1691 add_setshow_optional_filename_cmd ("scripts-directory", class_support
,
1692 &auto_load_dir
, _("\
1693 Set the list of directories from which to load auto-loaded scripts."), _("\
1694 Show the list of directories from which to load auto-loaded scripts."),
1695 scripts_directory_help
,
1696 set_auto_load_dir
, show_auto_load_dir
,
1697 auto_load_set_cmdlist_get (),
1698 auto_load_show_cmdlist_get ());
1699 xfree (scripts_directory_help
);
1700 xfree (python_name_help
);
1701 xfree (gdb_name_help
);
1702 xfree (guile_name_help
);
1704 auto_load_safe_path
= xstrdup (AUTO_LOAD_SAFE_PATH
);
1705 auto_load_safe_path_vec_update ();
1706 add_setshow_optional_filename_cmd ("safe-path", class_support
,
1707 &auto_load_safe_path
, _("\
1708 Set the list of files and directories that are safe for auto-loading."), _("\
1709 Show the list of files and directories that are safe for auto-loading."), _("\
1710 Various files loaded automatically for the 'set auto-load ...' options must\n\
1711 be located in one of the directories listed by this option. Warning will be\n\
1712 printed and file will not be used otherwise.\n\
1713 You can mix both directory and filename entries.\n\
1714 Setting this parameter to an empty list resets it to its default value.\n\
1715 Setting this parameter to '/' (without the quotes) allows any file\n\
1716 for the 'set auto-load ...' options. Each path entry can be also shell\n\
1717 wildcard pattern; '*' does not match directory separator.\n\
1718 This option is ignored for the kinds of files having 'set auto-load ... off'.\n\
1719 This options has security implications for untrusted inferiors."),
1720 set_auto_load_safe_path
,
1721 show_auto_load_safe_path
,
1722 auto_load_set_cmdlist_get (),
1723 auto_load_show_cmdlist_get ());
1724 observer_attach_gdb_datadir_changed (auto_load_gdb_datadir_changed
);
1726 cmd
= add_cmd ("add-auto-load-safe-path", class_support
,
1727 add_auto_load_safe_path
,
1728 _("Add entries to the list of directories from which it is safe "
1729 "to auto-load files.\n\
1730 See the commands 'set auto-load safe-path' and 'show auto-load safe-path' to\n\
1731 access the current full list setting."),
1733 set_cmd_completer (cmd
, filename_completer
);
1735 cmd
= add_cmd ("add-auto-load-scripts-directory", class_support
,
1737 _("Add entries to the list of directories from which to load "
1738 "auto-loaded scripts.\n\
1739 See the commands 'set auto-load scripts-directory' and\n\
1740 'show auto-load scripts-directory' to access the current full list setting."),
1742 set_cmd_completer (cmd
, filename_completer
);
1744 add_setshow_boolean_cmd ("auto-load", class_maintenance
,
1745 &debug_auto_load
, _("\
1746 Set auto-load verifications debugging."), _("\
1747 Show auto-load verifications debugging."), _("\
1748 When non-zero, debugging output for files of 'set auto-load ...'\n\
1750 NULL
, show_debug_auto_load
,
1751 &setdebuglist
, &showdebuglist
);