1 /* GDB routines for supporting auto-loaded scripts.
3 Copyright (C) 2012-2014 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 "gdb_regex.h"
25 #include "filenames.h"
29 #include "cli/cli-script.h"
31 #include "cli/cli-cmds.h"
32 #include "cli/cli-decode.h"
33 #include "cli/cli-setshow.h"
35 #include "readline/tilde.h"
36 #include "completer.h"
39 #include "filestuff.h"
40 #include "extension.h"
41 #include "gdb/section-scripts.h"
43 /* The section to look in for auto-loaded scripts (in file formats that
45 Each entry in this section is a record that begins with a leading byte
46 identifying the record type.
47 At the moment we only support one record type: A leading byte of 1,
48 followed by the path of a python script to load. */
49 #define AUTO_SECTION_NAME ".debug_gdb_scripts"
51 static int maybe_add_script (struct auto_load_pspace_info
*pspace_info
,
52 int loaded
, const char *name
,
53 const char *full_path
,
54 const struct extension_language_defn
*language
);
56 static int unsupported_script_warning_print (struct auto_load_pspace_info
*);
58 static int script_not_found_warning_print (struct auto_load_pspace_info
*);
60 /* Value of the 'set debug auto-load' configuration variable. */
61 static int debug_auto_load
= 0;
63 /* "show" command for the debug_auto_load configuration variable. */
66 show_debug_auto_load (struct ui_file
*file
, int from_tty
,
67 struct cmd_list_element
*c
, const char *value
)
69 fprintf_filtered (file
, _("Debugging output for files "
70 "of 'set auto-load ...' is %s.\n"),
74 /* User-settable option to enable/disable auto-loading of GDB_AUTO_FILE_NAME
76 set auto-load gdb-scripts on|off
77 This is true if we should auto-load associated scripts when an objfile
78 is opened, false otherwise. */
79 static int auto_load_gdb_scripts
= 1;
81 /* "show" command for the auto_load_gdb_scripts configuration variable. */
84 show_auto_load_gdb_scripts (struct ui_file
*file
, int from_tty
,
85 struct cmd_list_element
*c
, const char *value
)
87 fprintf_filtered (file
, _("Auto-loading of canned sequences of commands "
92 /* Return non-zero if auto-loading gdb scripts is enabled. */
95 auto_load_gdb_scripts_enabled (const struct extension_language_defn
*extlang
)
97 return auto_load_gdb_scripts
;
100 /* Internal-use flag to enable/disable auto-loading.
101 This is true if we should auto-load python code when an objfile is opened,
104 Both auto_load_scripts && global_auto_load must be true to enable
107 This flag exists to facilitate deferring auto-loading during start-up
108 until after ./.gdbinit has been read; it may augment the search directories
109 used to find the scripts. */
110 int global_auto_load
= 1;
112 /* Auto-load .gdbinit file from the current directory? */
113 int auto_load_local_gdbinit
= 1;
115 /* Absolute pathname to the current directory .gdbinit, if it exists. */
116 char *auto_load_local_gdbinit_pathname
= NULL
;
118 /* Boolean value if AUTO_LOAD_LOCAL_GDBINIT_PATHNAME has been loaded. */
119 int auto_load_local_gdbinit_loaded
= 0;
121 /* "show" command for the auto_load_local_gdbinit configuration variable. */
124 show_auto_load_local_gdbinit (struct ui_file
*file
, int from_tty
,
125 struct cmd_list_element
*c
, const char *value
)
127 fprintf_filtered (file
, _("Auto-loading of .gdbinit script from current "
128 "directory is %s.\n"),
132 /* Directory list from which to load auto-loaded scripts. It is not checked
133 for absolute paths but they are strongly recommended. It is initialized by
134 _initialize_auto_load. */
135 static char *auto_load_dir
;
137 /* "set" command for the auto_load_dir configuration variable. */
140 set_auto_load_dir (char *args
, int from_tty
, struct cmd_list_element
*c
)
142 /* Setting the variable to "" resets it to the compile time defaults. */
143 if (auto_load_dir
[0] == '\0')
145 xfree (auto_load_dir
);
146 auto_load_dir
= xstrdup (AUTO_LOAD_DIR
);
150 /* "show" command for the auto_load_dir configuration variable. */
153 show_auto_load_dir (struct ui_file
*file
, int from_tty
,
154 struct cmd_list_element
*c
, const char *value
)
156 fprintf_filtered (file
, _("List of directories from which to load "
157 "auto-loaded scripts is %s.\n"),
161 /* Directory list safe to hold auto-loaded files. It is not checked for
162 absolute paths but they are strongly recommended. It is initialized by
163 _initialize_auto_load. */
164 static char *auto_load_safe_path
;
166 /* Vector of directory elements of AUTO_LOAD_SAFE_PATH with each one normalized
167 by tilde_expand and possibly each entries has added its gdb_realpath
169 static VEC (char_ptr
) *auto_load_safe_path_vec
;
171 /* Expand $datadir and $debugdir in STRING according to the rules of
172 substitute_path_component. Return vector from dirnames_to_char_ptr_vec,
173 this vector must be freed by free_char_ptr_vec by the caller. */
175 static VEC (char_ptr
) *
176 auto_load_expand_dir_vars (const char *string
)
178 VEC (char_ptr
) *dir_vec
;
181 s
= xstrdup (string
);
182 substitute_path_component (&s
, "$datadir", gdb_datadir
);
183 substitute_path_component (&s
, "$debugdir", debug_file_directory
);
185 if (debug_auto_load
&& strcmp (s
, string
) != 0)
186 fprintf_unfiltered (gdb_stdlog
,
187 _("auto-load: Expanded $-variables to \"%s\".\n"), s
);
189 dir_vec
= dirnames_to_char_ptr_vec (s
);
195 /* Update auto_load_safe_path_vec from current AUTO_LOAD_SAFE_PATH. */
198 auto_load_safe_path_vec_update (void)
204 fprintf_unfiltered (gdb_stdlog
,
205 _("auto-load: Updating directories of \"%s\".\n"),
206 auto_load_safe_path
);
208 free_char_ptr_vec (auto_load_safe_path_vec
);
210 auto_load_safe_path_vec
= auto_load_expand_dir_vars (auto_load_safe_path
);
211 len
= VEC_length (char_ptr
, auto_load_safe_path_vec
);
213 /* Apply tilde_expand and gdb_realpath to each AUTO_LOAD_SAFE_PATH_VEC
215 for (ix
= 0; ix
< len
; ix
++)
217 char *dir
= VEC_index (char_ptr
, auto_load_safe_path_vec
, ix
);
218 char *expanded
= tilde_expand (dir
);
219 char *real_path
= gdb_realpath (expanded
);
221 /* Ensure the current entry is at least tilde_expand-ed. */
222 VEC_replace (char_ptr
, auto_load_safe_path_vec
, ix
, expanded
);
226 if (strcmp (expanded
, dir
) == 0)
227 fprintf_unfiltered (gdb_stdlog
,
228 _("auto-load: Using directory \"%s\".\n"),
231 fprintf_unfiltered (gdb_stdlog
,
232 _("auto-load: Resolved directory \"%s\" "
238 /* If gdb_realpath returns a different content, append it. */
239 if (strcmp (real_path
, expanded
) == 0)
243 VEC_safe_push (char_ptr
, auto_load_safe_path_vec
, real_path
);
246 fprintf_unfiltered (gdb_stdlog
,
247 _("auto-load: And canonicalized as \"%s\".\n"),
253 /* Variable gdb_datadir has been set. Update content depending on $datadir. */
256 auto_load_gdb_datadir_changed (void)
258 auto_load_safe_path_vec_update ();
261 /* "set" command for the auto_load_safe_path configuration variable. */
264 set_auto_load_safe_path (char *args
, int from_tty
, struct cmd_list_element
*c
)
266 /* Setting the variable to "" resets it to the compile time defaults. */
267 if (auto_load_safe_path
[0] == '\0')
269 xfree (auto_load_safe_path
);
270 auto_load_safe_path
= xstrdup (AUTO_LOAD_SAFE_PATH
);
273 auto_load_safe_path_vec_update ();
276 /* "show" command for the auto_load_safe_path configuration variable. */
279 show_auto_load_safe_path (struct ui_file
*file
, int from_tty
,
280 struct cmd_list_element
*c
, const char *value
)
284 /* Check if user has entered either "/" or for example ":".
285 But while more complicate content like ":/foo" would still also
286 permit any location do not hide those. */
288 for (cs
= value
; *cs
&& (*cs
== DIRNAME_SEPARATOR
|| IS_DIR_SEPARATOR (*cs
));
291 fprintf_filtered (file
, _("Auto-load files are safe to load from any "
294 fprintf_filtered (file
, _("List of directories from which it is safe to "
295 "auto-load files is %s.\n"),
299 /* "add-auto-load-safe-path" command for the auto_load_safe_path configuration
303 add_auto_load_safe_path (char *args
, int from_tty
)
307 if (args
== NULL
|| *args
== 0)
309 Directory argument required.\n\
310 Use 'set auto-load safe-path /' for disabling the auto-load safe-path security.\
313 s
= xstrprintf ("%s%c%s", auto_load_safe_path
, DIRNAME_SEPARATOR
, args
);
314 xfree (auto_load_safe_path
);
315 auto_load_safe_path
= s
;
317 auto_load_safe_path_vec_update ();
320 /* Implementation for filename_is_in_pattern overwriting the caller's FILENAME
324 filename_is_in_pattern_1 (char *filename
, char *pattern
)
326 size_t pattern_len
= strlen (pattern
);
327 size_t filename_len
= strlen (filename
);
330 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Matching file \"%s\" "
331 "to pattern \"%s\"\n"),
334 /* Trim trailing slashes ("/") from PATTERN. Even for "d:\" paths as
335 trailing slashes are trimmed also from FILENAME it still matches
337 while (pattern_len
&& IS_DIR_SEPARATOR (pattern
[pattern_len
- 1]))
339 pattern
[pattern_len
] = '\0';
341 /* Ensure auto_load_safe_path "/" matches any FILENAME. On MS-Windows
342 platform FILENAME even after gdb_realpath does not have to start with
343 IS_DIR_SEPARATOR character, such as the 'C:\x.exe' filename. */
344 if (pattern_len
== 0)
347 fprintf_unfiltered (gdb_stdlog
,
348 _("auto-load: Matched - empty pattern\n"));
354 /* Trim trailing slashes ("/"). PATTERN also has slashes trimmed the
355 same way so they will match. */
356 while (filename_len
&& IS_DIR_SEPARATOR (filename
[filename_len
- 1]))
358 filename
[filename_len
] = '\0';
359 if (filename_len
== 0)
362 fprintf_unfiltered (gdb_stdlog
,
363 _("auto-load: Not matched - pattern \"%s\".\n"),
368 if (gdb_filename_fnmatch (pattern
, filename
, FNM_FILE_NAME
| FNM_NOESCAPE
)
372 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Matched - file "
373 "\"%s\" to pattern \"%s\".\n"),
378 /* Trim trailing FILENAME component. */
379 while (filename_len
> 0 && !IS_DIR_SEPARATOR (filename
[filename_len
- 1]))
384 /* Return 1 if FILENAME matches PATTERN or if FILENAME resides in
385 a subdirectory of a directory that matches PATTERN. Return 0 otherwise.
386 gdb_realpath normalization is never done here. */
388 static ATTRIBUTE_PURE
int
389 filename_is_in_pattern (const char *filename
, const char *pattern
)
391 char *filename_copy
, *pattern_copy
;
393 filename_copy
= alloca (strlen (filename
) + 1);
394 strcpy (filename_copy
, filename
);
395 pattern_copy
= alloca (strlen (pattern
) + 1);
396 strcpy (pattern_copy
, pattern
);
398 return filename_is_in_pattern_1 (filename_copy
, pattern_copy
);
401 /* Return 1 if FILENAME belongs to one of directory components of
402 AUTO_LOAD_SAFE_PATH_VEC. Return 0 otherwise.
403 auto_load_safe_path_vec_update is never called.
404 *FILENAME_REALP may be updated by gdb_realpath of FILENAME - it has to be
405 freed by the caller. */
408 filename_is_in_auto_load_safe_path_vec (const char *filename
,
409 char **filename_realp
)
414 for (ix
= 0; VEC_iterate (char_ptr
, auto_load_safe_path_vec
, ix
, pattern
);
416 if (*filename_realp
== NULL
&& filename_is_in_pattern (filename
, pattern
))
421 if (*filename_realp
== NULL
)
423 *filename_realp
= gdb_realpath (filename
);
424 if (debug_auto_load
&& strcmp (*filename_realp
, filename
) != 0)
425 fprintf_unfiltered (gdb_stdlog
,
426 _("auto-load: Resolved "
427 "file \"%s\" as \"%s\".\n"),
428 filename
, *filename_realp
);
431 if (strcmp (*filename_realp
, filename
) != 0)
433 VEC_iterate (char_ptr
, auto_load_safe_path_vec
, ix
, pattern
); ++ix
)
434 if (filename_is_in_pattern (*filename_realp
, pattern
))
441 fprintf_unfiltered (gdb_stdlog
, _("auto-load: File \"%s\" matches "
442 "directory \"%s\".\n"),
450 /* Return 1 if FILENAME is located in one of the directories of
451 AUTO_LOAD_SAFE_PATH. Otherwise call warning and return 0. FILENAME does
452 not have to be an absolute path.
454 Existence of FILENAME is not checked. Function will still give a warning
455 even if the caller would quietly skip non-existing file in unsafe
459 file_is_auto_load_safe (const char *filename
, const char *debug_fmt
, ...)
461 char *filename_real
= NULL
;
462 struct cleanup
*back_to
;
463 static int advice_printed
= 0;
469 va_start (debug_args
, debug_fmt
);
470 vfprintf_unfiltered (gdb_stdlog
, debug_fmt
, debug_args
);
474 back_to
= make_cleanup (free_current_contents
, &filename_real
);
476 if (filename_is_in_auto_load_safe_path_vec (filename
, &filename_real
))
478 do_cleanups (back_to
);
482 auto_load_safe_path_vec_update ();
483 if (filename_is_in_auto_load_safe_path_vec (filename
, &filename_real
))
485 do_cleanups (back_to
);
489 warning (_("File \"%s\" auto-loading has been declined by your "
490 "`auto-load safe-path' set to \"%s\"."),
491 filename_real
, auto_load_safe_path
);
495 const char *homedir
= getenv ("HOME");
500 homeinit
= xstrprintf ("%s/%s", homedir
, gdbinit
);
501 make_cleanup (xfree
, homeinit
);
503 printf_filtered (_("\
504 To enable execution of this file add\n\
505 \tadd-auto-load-safe-path %s\n\
506 line to your configuration file \"%s\".\n\
507 To completely disable this security protection add\n\
508 \tset auto-load safe-path /\n\
509 line to your configuration file \"%s\".\n\
510 For more information about this security protection see the\n\
511 \"Auto-loading safe path\" section in the GDB manual. E.g., run from the shell:\n\
512 \tinfo \"(gdb)Auto-loading safe path\"\n"),
513 filename_real
, homeinit
, homeinit
);
517 do_cleanups (back_to
);
521 /* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
522 the same script. There's no point in loading the script multiple times,
523 and there can be a lot of objfiles and scripts, so we keep track of scripts
526 struct auto_load_pspace_info
528 /* For each program space we keep track of loaded scripts. */
529 struct htab
*loaded_scripts
;
531 /* Non-zero if we've issued the warning about an auto-load script not being
532 supported. We only want to issue this warning once. */
533 int unsupported_script_warning_printed
;
535 /* Non-zero if we've issued the warning about an auto-load script not being
536 found. We only want to issue this warning once. */
537 int script_not_found_warning_printed
;
540 /* Objects of this type are stored in the loaded script hash table. */
544 /* Name as provided by the objfile. */
547 /* Full path name or NULL if script wasn't found (or was otherwise
549 const char *full_path
;
551 /* Non-zero if this script has been loaded. */
554 const struct extension_language_defn
*language
;
557 /* Per-program-space data key. */
558 static const struct program_space_data
*auto_load_pspace_data
;
561 auto_load_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
563 struct auto_load_pspace_info
*info
= arg
;
565 if (info
->loaded_scripts
)
566 htab_delete (info
->loaded_scripts
);
570 /* Get the current autoload data. If none is found yet, add it now. This
571 function always returns a valid object. */
573 static struct auto_load_pspace_info
*
574 get_auto_load_pspace_data (struct program_space
*pspace
)
576 struct auto_load_pspace_info
*info
;
578 info
= program_space_data (pspace
, auto_load_pspace_data
);
581 info
= XCNEW (struct auto_load_pspace_info
);
582 set_program_space_data (pspace
, auto_load_pspace_data
, info
);
588 /* Hash function for the loaded script hash. */
591 hash_loaded_script_entry (const void *data
)
593 const struct loaded_script
*e
= data
;
595 return htab_hash_string (e
->name
) ^ htab_hash_pointer (e
->language
);
598 /* Equality function for the loaded script hash. */
601 eq_loaded_script_entry (const void *a
, const void *b
)
603 const struct loaded_script
*ea
= a
;
604 const struct loaded_script
*eb
= b
;
606 return strcmp (ea
->name
, eb
->name
) == 0 && ea
->language
== eb
->language
;
609 /* Initialize the table to track loaded scripts.
610 Each entry is hashed by the full path name. */
613 init_loaded_scripts_info (struct auto_load_pspace_info
*pspace_info
)
615 /* Choose 31 as the starting size of the hash table, somewhat arbitrarily.
616 Space for each entry is obtained with one malloc so we can free them
619 pspace_info
->loaded_scripts
= htab_create (31,
620 hash_loaded_script_entry
,
621 eq_loaded_script_entry
,
624 pspace_info
->unsupported_script_warning_printed
= FALSE
;
625 pspace_info
->script_not_found_warning_printed
= FALSE
;
628 /* Wrapper on get_auto_load_pspace_data to also allocate the hash table
629 for loading scripts. */
631 struct auto_load_pspace_info
*
632 get_auto_load_pspace_data_for_loading (struct program_space
*pspace
)
634 struct auto_load_pspace_info
*info
;
636 info
= get_auto_load_pspace_data (pspace
);
637 if (info
->loaded_scripts
== NULL
)
638 init_loaded_scripts_info (info
);
643 /* Add script NAME in LANGUAGE to hash table of PSPACE_INFO. LOADED 1 if the
644 script has been (is going to) be loaded, 0 otherwise (such as if it has not
645 been found). FULL_PATH is NULL if the script wasn't found. The result is
646 true if the script was already in the hash table. */
649 maybe_add_script (struct auto_load_pspace_info
*pspace_info
, int loaded
,
650 const char *name
, const char *full_path
,
651 const struct extension_language_defn
*language
)
653 struct htab
*htab
= pspace_info
->loaded_scripts
;
654 struct loaded_script
**slot
, entry
;
658 entry
.language
= language
;
659 slot
= (struct loaded_script
**) htab_find_slot (htab
, &entry
, INSERT
);
660 in_hash_table
= *slot
!= NULL
;
662 /* If this script is not in the hash table, add it. */
668 /* Allocate all space in one chunk so it's easier to free. */
669 *slot
= xmalloc (sizeof (**slot
)
671 + (full_path
!= NULL
? (strlen (full_path
) + 1) : 0));
672 p
= ((char*) *slot
) + sizeof (**slot
);
675 if (full_path
!= NULL
)
678 strcpy (p
, full_path
);
679 (*slot
)->full_path
= p
;
682 (*slot
)->full_path
= NULL
;
683 (*slot
)->loaded
= loaded
;
684 (*slot
)->language
= language
;
687 return in_hash_table
;
690 /* Clear the table of loaded section scripts. */
693 clear_section_scripts (void)
695 struct program_space
*pspace
= current_program_space
;
696 struct auto_load_pspace_info
*info
;
698 info
= program_space_data (pspace
, auto_load_pspace_data
);
699 if (info
!= NULL
&& info
->loaded_scripts
!= NULL
)
701 htab_delete (info
->loaded_scripts
);
702 info
->loaded_scripts
= NULL
;
703 info
->unsupported_script_warning_printed
= FALSE
;
704 info
->script_not_found_warning_printed
= FALSE
;
708 /* Look for the auto-load script in LANGUAGE associated with OBJFILE where
709 OBJFILE's gdb_realpath is REALNAME and load it. Return 1 if we found any
710 matching script, return 0 otherwise. */
713 auto_load_objfile_script_1 (struct objfile
*objfile
, const char *realname
,
714 const struct extension_language_defn
*language
)
716 char *filename
, *debugfile
;
719 struct cleanup
*cleanups
;
720 const char *suffix
= ext_lang_auto_load_suffix (language
);
722 len
= strlen (realname
);
723 filename
= xmalloc (len
+ strlen (suffix
) + 1);
724 memcpy (filename
, realname
, len
);
725 strcpy (filename
+ len
, suffix
);
727 cleanups
= make_cleanup (xfree
, filename
);
729 input
= gdb_fopen_cloexec (filename
, "r");
730 debugfile
= filename
;
732 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Attempted file \"%s\" %s.\n"),
733 debugfile
, input
? _("exists") : _("does not exist"));
741 /* Also try the same file in a subdirectory of gdb's data
744 vec
= auto_load_expand_dir_vars (auto_load_dir
);
745 make_cleanup_free_char_ptr_vec (vec
);
748 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Searching 'set auto-load "
749 "scripts-directory' path \"%s\".\n"),
752 for (ix
= 0; VEC_iterate (char_ptr
, vec
, ix
, dir
); ++ix
)
754 debugfile
= xmalloc (strlen (dir
) + strlen (filename
) + 1);
755 strcpy (debugfile
, dir
);
757 /* FILENAME is absolute, so we don't need a "/" here. */
758 strcat (debugfile
, filename
);
760 make_cleanup (xfree
, debugfile
);
761 input
= gdb_fopen_cloexec (debugfile
, "r");
763 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Attempted file "
766 input
? _("exists") : _("does not exist"));
775 struct auto_load_pspace_info
*pspace_info
;
777 make_cleanup_fclose (input
);
780 = file_is_auto_load_safe (debugfile
,
781 _("auto-load: Loading %s script \"%s\""
782 " by extension for objfile \"%s\".\n"),
783 ext_lang_name (language
),
784 debugfile
, objfile_name (objfile
));
786 /* Add this script to the hash table too so
787 "info auto-load ${lang}-scripts" can print it. */
789 = get_auto_load_pspace_data_for_loading (current_program_space
);
790 maybe_add_script (pspace_info
, is_safe
, debugfile
, debugfile
, language
);
792 /* To preserve existing behaviour we don't check for whether the
793 script was already in the table, and always load it.
794 It's highly unlikely that we'd ever load it twice,
795 and these scripts are required to be idempotent under multiple
799 objfile_script_sourcer_func
*sourcer
800 = ext_lang_objfile_script_sourcer (language
);
802 /* We shouldn't get here if support for the language isn't
803 compiled in. And the extension language is required to implement
805 gdb_assert (sourcer
!= NULL
);
806 sourcer (language
, objfile
, input
, debugfile
);
814 do_cleanups (cleanups
);
818 /* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
822 auto_load_objfile_script (struct objfile
*objfile
,
823 const struct extension_language_defn
*language
)
825 char *realname
= gdb_realpath (objfile_name (objfile
));
826 struct cleanup
*cleanups
= make_cleanup (xfree
, realname
);
828 if (!auto_load_objfile_script_1 (objfile
, realname
, language
))
830 /* For Windows/DOS .exe executables, strip the .exe suffix, so that
831 FOO-gdb.gdb could be used for FOO.exe, and try again. */
833 size_t len
= strlen (realname
);
834 const size_t lexe
= sizeof (".exe") - 1;
836 if (len
> lexe
&& strcasecmp (realname
+ len
- lexe
, ".exe") == 0)
839 realname
[len
] = '\0';
841 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Stripped .exe suffix, "
842 "retrying with \"%s\".\n"),
844 auto_load_objfile_script_1 (objfile
, realname
, language
);
848 do_cleanups (cleanups
);
851 /* Load scripts specified in OBJFILE.
852 START,END delimit a buffer containing a list of nul-terminated
854 SECTION_NAME is used in error messages.
856 Scripts are found per normal "source -s" command processing.
857 First the script is looked for in $cwd. If not found there the
858 source search path is used.
860 The section contains a list of path names of script files to load.
861 Each path is null-terminated. */
864 source_section_scripts (struct objfile
*objfile
, const char *section_name
,
865 const char *start
, const char *end
)
868 struct auto_load_pspace_info
*pspace_info
;
870 pspace_info
= get_auto_load_pspace_data_for_loading (current_program_space
);
872 for (p
= start
; p
< end
; ++p
)
877 int opened
, in_hash_table
;
878 struct cleanup
*back_to
;
879 const struct extension_language_defn
*language
;
880 objfile_script_sourcer_func
*sourcer
;
884 case SECTION_SCRIPT_ID_PYTHON_FILE
:
885 language
= get_ext_lang_defn (EXT_LANG_PYTHON
);
887 case SECTION_SCRIPT_ID_SCHEME_FILE
:
888 language
= get_ext_lang_defn (EXT_LANG_GUILE
);
891 warning (_("Invalid entry in %s section"), section_name
);
892 /* We could try various heuristics to find the next valid entry,
893 but it's safer to just punt. */
898 while (p
< end
&& *p
!= '\0')
902 char *buf
= alloca (p
- file
+ 1);
904 memcpy (buf
, file
, p
- file
);
905 buf
[p
- file
] = '\0';
906 warning (_("Non-null-terminated path in %s: %s"),
913 warning (_("Empty path in %s"), section_name
);
917 /* Until we support more types of records in .debug_gdb_scripts we do
918 all the processing here. The expectation is to add a new
919 extension_language_script_ops "method" that handles all the records
920 for the language. For now we can just use
921 extension_language_script_ops.objfile_script_sourcer. */
923 /* Skip this script if support is not compiled in. */
924 sourcer
= ext_lang_objfile_script_sourcer (language
);
927 /* We don't throw an error, the program is still debuggable. */
928 if (!unsupported_script_warning_print (pspace_info
))
930 warning (_("Unsupported auto-load scripts referenced in"
933 "Use `info auto-load %s-scripts [REGEXP]'"
935 section_name
, objfile_name (objfile
),
936 ext_lang_name (language
));
938 /* We *could* still try to open it, but there's no point. */
939 maybe_add_script (pspace_info
, 0, file
, NULL
, language
);
943 /* Skip this script if auto-loading it has been disabled. */
944 if (!ext_lang_auto_load_enabled (language
))
946 /* No message is printed, just skip it. */
950 opened
= find_and_open_script (file
, 1 /*search_path*/,
951 &stream
, &full_path
);
953 back_to
= make_cleanup (null_cleanup
, NULL
);
956 make_cleanup_fclose (stream
);
957 make_cleanup (xfree
, full_path
);
959 if (!file_is_auto_load_safe (full_path
,
960 _("auto-load: Loading %s script "
961 "\"%s\" from section \"%s\" of "
962 "objfile \"%s\".\n"),
963 ext_lang_name (language
), full_path
,
964 section_name
, objfile_name (objfile
)))
971 /* If one script isn't found it's not uncommon for more to not be
972 found either. We don't want to print a message for each script,
973 too much noise. Instead, we print the warning once and tell the
974 user how to find the list of scripts that weren't loaded.
975 We don't throw an error, the program is still debuggable.
977 IWBN if complaints.c were more general-purpose. */
979 if (script_not_found_warning_print (pspace_info
))
980 warning (_("Missing auto-load scripts referenced in section %s\n\
982 Use `info auto-load %s-scripts [REGEXP]' to list them."),
983 section_name
, objfile_name (objfile
),
984 ext_lang_name (language
));
987 in_hash_table
= maybe_add_script (pspace_info
, opened
, file
, full_path
,
990 /* If this file is not currently loaded, load it. */
991 if (opened
&& !in_hash_table
)
992 sourcer (language
, objfile
, stream
, full_path
);
994 do_cleanups (back_to
);
998 /* Load scripts specified in section SECTION_NAME of OBJFILE. */
1001 auto_load_section_scripts (struct objfile
*objfile
, const char *section_name
)
1003 bfd
*abfd
= objfile
->obfd
;
1004 asection
*scripts_sect
;
1005 bfd_byte
*data
= NULL
;
1007 scripts_sect
= bfd_get_section_by_name (abfd
, section_name
);
1008 if (scripts_sect
== NULL
)
1011 if (!bfd_get_full_section_contents (abfd
, scripts_sect
, &data
))
1012 warning (_("Couldn't read %s section of %s"),
1013 section_name
, bfd_get_filename (abfd
));
1016 struct cleanup
*cleanups
;
1017 char *p
= (char *) data
;
1019 cleanups
= make_cleanup (xfree
, p
);
1020 source_section_scripts (objfile
, section_name
, p
,
1021 p
+ bfd_get_section_size (scripts_sect
));
1022 do_cleanups (cleanups
);
1026 /* Load any auto-loaded scripts for OBJFILE. */
1029 load_auto_scripts_for_objfile (struct objfile
*objfile
)
1031 /* Return immediately if auto-loading has been globally disabled.
1032 This is to handle sequencing of operations during gdb startup.
1033 Also return immediately if OBJFILE is not actually a file. */
1034 if (!global_auto_load
|| (objfile
->flags
& OBJF_NOT_FILENAME
) != 0)
1037 /* Load any extension language scripts for this objfile.
1038 E.g., foo-gdb.gdb, foo-gdb.py. */
1039 auto_load_ext_lang_scripts_for_objfile (objfile
);
1041 /* Load any scripts mentioned in AUTO_SECTION_NAME (.debug_gdb_scripts). */
1042 auto_load_section_scripts (objfile
, AUTO_SECTION_NAME
);
1045 /* This is a new_objfile observer callback to auto-load scripts.
1047 Two flavors of auto-loaded scripts are supported.
1048 1) based on the path to the objfile
1049 2) from .debug_gdb_scripts section */
1052 auto_load_new_objfile (struct objfile
*objfile
)
1056 /* OBJFILE is NULL when loading a new "main" symbol-file. */
1057 clear_section_scripts ();
1061 load_auto_scripts_for_objfile (objfile
);
1064 /* Collect scripts to be printed in a vec. */
1066 typedef struct loaded_script
*loaded_script_ptr
;
1067 DEF_VEC_P (loaded_script_ptr
);
1069 struct collect_matching_scripts_data
1071 VEC (loaded_script_ptr
) **scripts_p
;
1073 const struct extension_language_defn
*language
;
1076 /* Traversal function for htab_traverse.
1077 Collect the entry if it matches the regexp. */
1080 collect_matching_scripts (void **slot
, void *info
)
1082 struct loaded_script
*script
= *slot
;
1083 struct collect_matching_scripts_data
*data
= info
;
1085 if (script
->language
== data
->language
&& re_exec (script
->name
))
1086 VEC_safe_push (loaded_script_ptr
, *data
->scripts_p
, script
);
1094 print_script (struct loaded_script
*script
)
1096 struct ui_out
*uiout
= current_uiout
;
1097 struct cleanup
*chain
;
1099 chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1101 ui_out_field_string (uiout
, "loaded", script
->loaded
? "Yes" : "No");
1102 ui_out_field_string (uiout
, "script", script
->name
);
1103 ui_out_text (uiout
, "\n");
1105 /* If the name isn't the full path, print it too. */
1106 if (script
->full_path
!= NULL
1107 && strcmp (script
->name
, script
->full_path
) != 0)
1109 ui_out_text (uiout
, "\tfull name: ");
1110 ui_out_field_string (uiout
, "full_path", script
->full_path
);
1111 ui_out_text (uiout
, "\n");
1114 do_cleanups (chain
);
1117 /* Helper for info_auto_load_scripts to sort the scripts by name. */
1120 sort_scripts_by_name (const void *ap
, const void *bp
)
1122 const struct loaded_script
*a
= *(const struct loaded_script
**) ap
;
1123 const struct loaded_script
*b
= *(const struct loaded_script
**) bp
;
1125 return FILENAME_CMP (a
->name
, b
->name
);
1128 /* Special internal GDB value of auto_load_info_scripts's PATTERN identify
1129 the "info auto-load XXX" command has been executed through the general
1130 "info auto-load" invocation. Extra newline will be printed if needed. */
1131 char auto_load_info_scripts_pattern_nl
[] = "";
1133 /* Implementation for "info auto-load gdb-scripts"
1134 (and "info auto-load python-scripts"). List scripts in LANGUAGE matching
1135 PATTERN. FROM_TTY is the usual GDB boolean for user interactivity. */
1138 auto_load_info_scripts (char *pattern
, int from_tty
,
1139 const struct extension_language_defn
*language
)
1141 struct ui_out
*uiout
= current_uiout
;
1142 struct auto_load_pspace_info
*pspace_info
;
1143 struct cleanup
*script_chain
;
1144 VEC (loaded_script_ptr
) *scripts
;
1149 pspace_info
= get_auto_load_pspace_data (current_program_space
);
1151 if (pattern
&& *pattern
)
1153 char *re_err
= re_comp (pattern
);
1156 error (_("Invalid regexp: %s"), re_err
);
1163 /* We need to know the number of rows before we build the table.
1164 Plus we want to sort the scripts by name.
1165 So first traverse the hash table collecting the matching scripts. */
1167 scripts
= VEC_alloc (loaded_script_ptr
, 10);
1168 script_chain
= make_cleanup (VEC_cleanup (loaded_script_ptr
), &scripts
);
1170 if (pspace_info
!= NULL
&& pspace_info
->loaded_scripts
!= NULL
)
1172 struct collect_matching_scripts_data data
= { &scripts
, language
};
1174 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
1175 htab_traverse_noresize (pspace_info
->loaded_scripts
,
1176 collect_matching_scripts
, &data
);
1179 nr_scripts
= VEC_length (loaded_script_ptr
, scripts
);
1181 /* Table header shifted right by preceding "gdb-scripts: " would not match
1183 if (nr_scripts
> 0 && pattern
== auto_load_info_scripts_pattern_nl
)
1184 ui_out_text (uiout
, "\n");
1186 make_cleanup_ui_out_table_begin_end (uiout
, 2, nr_scripts
,
1187 "AutoLoadedScriptsTable");
1189 ui_out_table_header (uiout
, 7, ui_left
, "loaded", "Loaded");
1190 ui_out_table_header (uiout
, 70, ui_left
, "script", "Script");
1191 ui_out_table_body (uiout
);
1196 loaded_script_ptr script
;
1198 qsort (VEC_address (loaded_script_ptr
, scripts
),
1199 VEC_length (loaded_script_ptr
, scripts
),
1200 sizeof (loaded_script_ptr
), sort_scripts_by_name
);
1201 for (i
= 0; VEC_iterate (loaded_script_ptr
, scripts
, i
, script
); ++i
)
1202 print_script (script
);
1205 do_cleanups (script_chain
);
1207 if (nr_scripts
== 0)
1209 if (pattern
&& *pattern
)
1210 ui_out_message (uiout
, 0, "No auto-load scripts matching %s.\n",
1213 ui_out_message (uiout
, 0, "No auto-load scripts.\n");
1217 /* Wrapper for "info auto-load gdb-scripts". */
1220 info_auto_load_gdb_scripts (char *pattern
, int from_tty
)
1222 auto_load_info_scripts (pattern
, from_tty
, &extension_language_gdb
);
1225 /* Implement 'info auto-load local-gdbinit'. */
1228 info_auto_load_local_gdbinit (char *args
, int from_tty
)
1230 if (auto_load_local_gdbinit_pathname
== NULL
)
1231 printf_filtered (_("Local .gdbinit file was not found.\n"));
1232 else if (auto_load_local_gdbinit_loaded
)
1233 printf_filtered (_("Local .gdbinit file \"%s\" has been loaded.\n"),
1234 auto_load_local_gdbinit_pathname
);
1236 printf_filtered (_("Local .gdbinit file \"%s\" has not been loaded.\n"),
1237 auto_load_local_gdbinit_pathname
);
1240 /* Return non-zero if UNSUPPORTED_SCRIPT_WARNING_PRINTED of PSPACE_INFO was
1241 unset before calling this function. Always set
1242 UNSUPPORTED_SCRIPT_WARNING_PRINTED of PSPACE_INFO. */
1245 unsupported_script_warning_print (struct auto_load_pspace_info
*pspace_info
)
1247 int retval
= !pspace_info
->unsupported_script_warning_printed
;
1249 pspace_info
->unsupported_script_warning_printed
= 1;
1254 /* Return non-zero if SCRIPT_NOT_FOUND_WARNING_PRINTED of PSPACE_INFO was unset
1255 before calling this function. Always set SCRIPT_NOT_FOUND_WARNING_PRINTED
1259 script_not_found_warning_print (struct auto_load_pspace_info
*pspace_info
)
1261 int retval
= !pspace_info
->script_not_found_warning_printed
;
1263 pspace_info
->script_not_found_warning_printed
= 1;
1268 /* The only valid "set auto-load" argument is off|0|no|disable. */
1271 set_auto_load_cmd (char *args
, int from_tty
)
1273 struct cmd_list_element
*list
;
1276 /* See parse_binary_operation in use by the sub-commands. */
1278 length
= args
? strlen (args
) : 0;
1280 while (length
> 0 && (args
[length
- 1] == ' ' || args
[length
- 1] == '\t'))
1283 if (length
== 0 || (strncmp (args
, "off", length
) != 0
1284 && strncmp (args
, "0", length
) != 0
1285 && strncmp (args
, "no", length
) != 0
1286 && strncmp (args
, "disable", length
) != 0))
1287 error (_("Valid is only global 'set auto-load no'; "
1288 "otherwise check the auto-load sub-commands."));
1290 for (list
= *auto_load_set_cmdlist_get (); list
!= NULL
; list
= list
->next
)
1291 if (list
->var_type
== var_boolean
)
1293 gdb_assert (list
->type
== set_cmd
);
1294 do_set_command (args
, from_tty
, list
);
1298 /* Initialize "set auto-load " commands prefix and return it. */
1300 struct cmd_list_element
**
1301 auto_load_set_cmdlist_get (void)
1303 static struct cmd_list_element
*retval
;
1306 add_prefix_cmd ("auto-load", class_maintenance
, set_auto_load_cmd
, _("\
1307 Auto-loading specific settings.\n\
1308 Configure various auto-load-specific variables such as\n\
1309 automatic loading of Python scripts."),
1310 &retval
, "set auto-load ",
1311 1/*allow-unknown*/, &setlist
);
1316 /* Command "show auto-load" displays summary of all the current
1317 "show auto-load " settings. */
1320 show_auto_load_cmd (char *args
, int from_tty
)
1322 cmd_show_list (*auto_load_show_cmdlist_get (), from_tty
, "");
1325 /* Initialize "show auto-load " commands prefix and return it. */
1327 struct cmd_list_element
**
1328 auto_load_show_cmdlist_get (void)
1330 static struct cmd_list_element
*retval
;
1333 add_prefix_cmd ("auto-load", class_maintenance
, show_auto_load_cmd
, _("\
1334 Show auto-loading specific settings.\n\
1335 Show configuration of various auto-load-specific variables such as\n\
1336 automatic loading of Python scripts."),
1337 &retval
, "show auto-load ",
1338 0/*allow-unknown*/, &showlist
);
1343 /* Command "info auto-load" displays whether the various auto-load files have
1344 been loaded. This is reimplementation of cmd_show_list which inserts
1345 newlines at proper places. */
1348 info_auto_load_cmd (char *args
, int from_tty
)
1350 struct cmd_list_element
*list
;
1351 struct cleanup
*infolist_chain
;
1352 struct ui_out
*uiout
= current_uiout
;
1354 infolist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "infolist");
1356 for (list
= *auto_load_info_cmdlist_get (); list
!= NULL
; list
= list
->next
)
1358 struct cleanup
*option_chain
1359 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
1361 gdb_assert (!list
->prefixlist
);
1362 gdb_assert (list
->type
== not_set_cmd
);
1364 ui_out_field_string (uiout
, "name", list
->name
);
1365 ui_out_text (uiout
, ": ");
1366 cmd_func (list
, auto_load_info_scripts_pattern_nl
, from_tty
);
1368 /* Close the tuple. */
1369 do_cleanups (option_chain
);
1372 /* Close the tuple. */
1373 do_cleanups (infolist_chain
);
1376 /* Initialize "info auto-load " commands prefix and return it. */
1378 struct cmd_list_element
**
1379 auto_load_info_cmdlist_get (void)
1381 static struct cmd_list_element
*retval
;
1384 add_prefix_cmd ("auto-load", class_info
, info_auto_load_cmd
, _("\
1385 Print current status of auto-loaded files.\n\
1386 Print whether various files like Python scripts or .gdbinit files have been\n\
1387 found and/or loaded."),
1388 &retval
, "info auto-load ",
1389 0/*allow-unknown*/, &infolist
);
1394 void _initialize_auto_load (void);
1397 _initialize_auto_load (void)
1399 struct cmd_list_element
*cmd
;
1400 char *scripts_directory_help
, *gdb_name_help
, *python_name_help
;
1401 char *guile_name_help
;
1404 auto_load_pspace_data
1405 = register_program_space_data_with_cleanup (NULL
,
1406 auto_load_pspace_data_cleanup
);
1408 observer_attach_new_objfile (auto_load_new_objfile
);
1410 add_setshow_boolean_cmd ("gdb-scripts", class_support
,
1411 &auto_load_gdb_scripts
, _("\
1412 Enable or disable auto-loading of canned sequences of commands scripts."), _("\
1413 Show whether auto-loading of canned sequences of commands scripts is enabled."),
1415 If enabled, canned sequences of commands are loaded when the debugger reads\n\
1416 an executable or shared library.\n\
1417 This options has security implications for untrusted inferiors."),
1418 NULL
, show_auto_load_gdb_scripts
,
1419 auto_load_set_cmdlist_get (),
1420 auto_load_show_cmdlist_get ());
1422 add_cmd ("gdb-scripts", class_info
, info_auto_load_gdb_scripts
,
1423 _("Print the list of automatically loaded sequences of commands.\n\
1424 Usage: info auto-load gdb-scripts [REGEXP]"),
1425 auto_load_info_cmdlist_get ());
1427 add_setshow_boolean_cmd ("local-gdbinit", class_support
,
1428 &auto_load_local_gdbinit
, _("\
1429 Enable or disable auto-loading of .gdbinit script in current directory."), _("\
1430 Show whether auto-loading .gdbinit script in current directory is enabled."),
1432 If enabled, canned sequences of commands are loaded when debugger starts\n\
1433 from .gdbinit file in current directory. Such files are deprecated,\n\
1434 use a script associated with inferior executable file instead.\n\
1435 This options has security implications for untrusted inferiors."),
1436 NULL
, show_auto_load_local_gdbinit
,
1437 auto_load_set_cmdlist_get (),
1438 auto_load_show_cmdlist_get ());
1440 add_cmd ("local-gdbinit", class_info
, info_auto_load_local_gdbinit
,
1441 _("Print whether current directory .gdbinit file has been loaded.\n\
1442 Usage: info auto-load local-gdbinit"),
1443 auto_load_info_cmdlist_get ());
1445 auto_load_dir
= xstrdup (AUTO_LOAD_DIR
);
1447 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GDB
));
1450 GDB scripts: OBJFILE%s\n"),
1452 python_name_help
= NULL
;
1454 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_PYTHON
));
1457 Python scripts: OBJFILE%s\n"),
1460 guile_name_help
= NULL
;
1462 suffix
= ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GUILE
));
1465 Guile scripts: OBJFILE%s\n"),
1468 scripts_directory_help
1470 Automatically loaded scripts are located in one of the directories listed\n\
1476 This option is ignored for the kinds of scripts \
1477 having 'set auto-load ... off'.\n\
1478 Directories listed here need to be present also \
1479 in the 'set auto-load safe-path'\n\
1482 python_name_help
? python_name_help
: "",
1483 guile_name_help
? guile_name_help
: "");
1485 add_setshow_optional_filename_cmd ("scripts-directory", class_support
,
1486 &auto_load_dir
, _("\
1487 Set the list of directories from which to load auto-loaded scripts."), _("\
1488 Show the list of directories from which to load auto-loaded scripts."),
1489 scripts_directory_help
,
1490 set_auto_load_dir
, show_auto_load_dir
,
1491 auto_load_set_cmdlist_get (),
1492 auto_load_show_cmdlist_get ());
1493 xfree (scripts_directory_help
);
1494 xfree (python_name_help
);
1495 xfree (gdb_name_help
);
1496 xfree (guile_name_help
);
1498 auto_load_safe_path
= xstrdup (AUTO_LOAD_SAFE_PATH
);
1499 auto_load_safe_path_vec_update ();
1500 add_setshow_optional_filename_cmd ("safe-path", class_support
,
1501 &auto_load_safe_path
, _("\
1502 Set the list of files and directories that are safe for auto-loading."), _("\
1503 Show the list of files and directories that are safe for auto-loading."), _("\
1504 Various files loaded automatically for the 'set auto-load ...' options must\n\
1505 be located in one of the directories listed by this option. Warning will be\n\
1506 printed and file will not be used otherwise.\n\
1507 You can mix both directory and filename entries.\n\
1508 Setting this parameter to an empty list resets it to its default value.\n\
1509 Setting this parameter to '/' (without the quotes) allows any file\n\
1510 for the 'set auto-load ...' options. Each path entry can be also shell\n\
1511 wildcard pattern; '*' does not match directory separator.\n\
1512 This option is ignored for the kinds of files having 'set auto-load ... off'.\n\
1513 This options has security implications for untrusted inferiors."),
1514 set_auto_load_safe_path
,
1515 show_auto_load_safe_path
,
1516 auto_load_set_cmdlist_get (),
1517 auto_load_show_cmdlist_get ());
1518 observer_attach_gdb_datadir_changed (auto_load_gdb_datadir_changed
);
1520 cmd
= add_cmd ("add-auto-load-safe-path", class_support
,
1521 add_auto_load_safe_path
,
1522 _("Add entries to the list of directories from which it is safe "
1523 "to auto-load files.\n\
1524 See the commands 'set auto-load safe-path' and 'show auto-load safe-path' to\n\
1525 access the current full list setting."),
1527 set_cmd_completer (cmd
, filename_completer
);
1529 add_setshow_boolean_cmd ("auto-load", class_maintenance
,
1530 &debug_auto_load
, _("\
1531 Set auto-load verifications debugging."), _("\
1532 Show auto-load verifications debugging."), _("\
1533 When non-zero, debugging output for files of 'set auto-load ...'\n\
1535 NULL
, show_debug_auto_load
,
1536 &setdebuglist
, &showdebuglist
);