1 /* GDB routines for supporting auto-loaded scripts.
3 Copyright (C) 2012-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "auto-load.h"
22 #include "progspace.h"
23 #include "python/python.h"
24 #include "gdb_regex.h"
26 #include "filenames.h"
30 #include "exceptions.h"
31 #include "cli/cli-script.h"
33 #include "cli/cli-cmds.h"
34 #include "cli/cli-decode.h"
35 #include "cli/cli-setshow.h"
37 #include "readline/tilde.h"
38 #include "completer.h"
42 #include "filestuff.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 /* The suffix of per-objfile scripts to auto-load as non-Python command files.
53 E.g. When the program loads libfoo.so, look for libfoo-gdb.gdb. */
54 #define GDB_AUTO_FILE_NAME "-gdb.gdb"
56 static void source_gdb_script_for_objfile (struct objfile
*objfile
, FILE *file
,
57 const char *filename
);
59 /* Value of the 'set debug auto-load' configuration variable. */
60 static int debug_auto_load
= 0;
62 /* "show" command for the debug_auto_load configuration variable. */
65 show_debug_auto_load (struct ui_file
*file
, int from_tty
,
66 struct cmd_list_element
*c
, const char *value
)
68 fprintf_filtered (file
, _("Debugging output for files "
69 "of 'set auto-load ...' is %s.\n"),
73 /* User-settable option to enable/disable auto-loading of GDB_AUTO_FILE_NAME
75 set auto-load gdb-scripts on|off
76 This is true if we should auto-load associated scripts when an objfile
77 is opened, false otherwise. */
78 static int auto_load_gdb_scripts
= 1;
80 /* "show" command for the auto_load_gdb_scripts configuration variable. */
83 show_auto_load_gdb_scripts (struct ui_file
*file
, int from_tty
,
84 struct cmd_list_element
*c
, const char *value
)
86 fprintf_filtered (file
, _("Auto-loading of canned sequences of commands "
91 /* Return non-zero if auto-loading gdb scripts is enabled. */
94 auto_load_gdb_scripts_enabled (void)
96 return auto_load_gdb_scripts
;
99 /* Internal-use flag to enable/disable auto-loading.
100 This is true if we should auto-load python code when an objfile is opened,
103 Both auto_load_scripts && global_auto_load must be true to enable
106 This flag exists to facilitate deferring auto-loading during start-up
107 until after ./.gdbinit has been read; it may augment the search directories
108 used to find the scripts. */
109 int global_auto_load
= 1;
111 /* Auto-load .gdbinit file from the current directory? */
112 int auto_load_local_gdbinit
= 1;
114 /* Absolute pathname to the current directory .gdbinit, if it exists. */
115 char *auto_load_local_gdbinit_pathname
= NULL
;
117 /* Boolean value if AUTO_LOAD_LOCAL_GDBINIT_PATHNAME has been loaded. */
118 int auto_load_local_gdbinit_loaded
= 0;
120 /* "show" command for the auto_load_local_gdbinit configuration variable. */
123 show_auto_load_local_gdbinit (struct ui_file
*file
, int from_tty
,
124 struct cmd_list_element
*c
, const char *value
)
126 fprintf_filtered (file
, _("Auto-loading of .gdbinit script from current "
127 "directory is %s.\n"),
131 /* Directory list from which to load auto-loaded scripts. It is not checked
132 for absolute paths but they are strongly recommended. It is initialized by
133 _initialize_auto_load. */
134 static char *auto_load_dir
;
136 /* "set" command for the auto_load_dir configuration variable. */
139 set_auto_load_dir (char *args
, int from_tty
, struct cmd_list_element
*c
)
141 /* Setting the variable to "" resets it to the compile time defaults. */
142 if (auto_load_dir
[0] == '\0')
144 xfree (auto_load_dir
);
145 auto_load_dir
= xstrdup (AUTO_LOAD_DIR
);
149 /* "show" command for the auto_load_dir configuration variable. */
152 show_auto_load_dir (struct ui_file
*file
, int from_tty
,
153 struct cmd_list_element
*c
, const char *value
)
155 fprintf_filtered (file
, _("List of directories from which to load "
156 "auto-loaded scripts is %s.\n"),
160 /* Directory list safe to hold auto-loaded files. It is not checked for
161 absolute paths but they are strongly recommended. It is initialized by
162 _initialize_auto_load. */
163 static char *auto_load_safe_path
;
165 /* Vector of directory elements of AUTO_LOAD_SAFE_PATH with each one normalized
166 by tilde_expand and possibly each entries has added its gdb_realpath
168 static VEC (char_ptr
) *auto_load_safe_path_vec
;
170 /* Expand $datadir and $debugdir in STRING according to the rules of
171 substitute_path_component. Return vector from dirnames_to_char_ptr_vec,
172 this vector must be freed by free_char_ptr_vec by the caller. */
174 static VEC (char_ptr
) *
175 auto_load_expand_dir_vars (const char *string
)
177 VEC (char_ptr
) *dir_vec
;
180 s
= xstrdup (string
);
181 substitute_path_component (&s
, "$datadir", gdb_datadir
);
182 substitute_path_component (&s
, "$debugdir", debug_file_directory
);
184 if (debug_auto_load
&& strcmp (s
, string
) != 0)
185 fprintf_unfiltered (gdb_stdlog
,
186 _("auto-load: Expanded $-variables to \"%s\".\n"), s
);
188 dir_vec
= dirnames_to_char_ptr_vec (s
);
194 /* Update auto_load_safe_path_vec from current AUTO_LOAD_SAFE_PATH. */
197 auto_load_safe_path_vec_update (void)
203 fprintf_unfiltered (gdb_stdlog
,
204 _("auto-load: Updating directories of \"%s\".\n"),
205 auto_load_safe_path
);
207 free_char_ptr_vec (auto_load_safe_path_vec
);
209 auto_load_safe_path_vec
= auto_load_expand_dir_vars (auto_load_safe_path
);
210 len
= VEC_length (char_ptr
, auto_load_safe_path_vec
);
212 /* Apply tilde_expand and gdb_realpath to each AUTO_LOAD_SAFE_PATH_VEC
214 for (ix
= 0; ix
< len
; ix
++)
216 char *dir
= VEC_index (char_ptr
, auto_load_safe_path_vec
, ix
);
217 char *expanded
= tilde_expand (dir
);
218 char *real_path
= gdb_realpath (expanded
);
220 /* Ensure the current entry is at least tilde_expand-ed. */
221 VEC_replace (char_ptr
, auto_load_safe_path_vec
, ix
, expanded
);
225 if (strcmp (expanded
, dir
) == 0)
226 fprintf_unfiltered (gdb_stdlog
,
227 _("auto-load: Using directory \"%s\".\n"),
230 fprintf_unfiltered (gdb_stdlog
,
231 _("auto-load: Resolved directory \"%s\" "
237 /* If gdb_realpath returns a different content, append it. */
238 if (strcmp (real_path
, expanded
) == 0)
242 VEC_safe_push (char_ptr
, auto_load_safe_path_vec
, real_path
);
245 fprintf_unfiltered (gdb_stdlog
,
246 _("auto-load: And canonicalized as \"%s\".\n"),
252 /* Variable gdb_datadir has been set. Update content depending on $datadir. */
255 auto_load_gdb_datadir_changed (void)
257 auto_load_safe_path_vec_update ();
260 /* "set" command for the auto_load_safe_path configuration variable. */
263 set_auto_load_safe_path (char *args
, int from_tty
, struct cmd_list_element
*c
)
265 /* Setting the variable to "" resets it to the compile time defaults. */
266 if (auto_load_safe_path
[0] == '\0')
268 xfree (auto_load_safe_path
);
269 auto_load_safe_path
= xstrdup (AUTO_LOAD_SAFE_PATH
);
272 auto_load_safe_path_vec_update ();
275 /* "show" command for the auto_load_safe_path configuration variable. */
278 show_auto_load_safe_path (struct ui_file
*file
, int from_tty
,
279 struct cmd_list_element
*c
, const char *value
)
283 /* Check if user has entered either "/" or for example ":".
284 But while more complicate content like ":/foo" would still also
285 permit any location do not hide those. */
287 for (cs
= value
; *cs
&& (*cs
== DIRNAME_SEPARATOR
|| IS_DIR_SEPARATOR (*cs
));
290 fprintf_filtered (file
, _("Auto-load files are safe to load from any "
293 fprintf_filtered (file
, _("List of directories from which it is safe to "
294 "auto-load files is %s.\n"),
298 /* "add-auto-load-safe-path" command for the auto_load_safe_path configuration
302 add_auto_load_safe_path (char *args
, int from_tty
)
306 if (args
== NULL
|| *args
== 0)
308 Directory argument required.\n\
309 Use 'set auto-load safe-path /' for disabling the auto-load safe-path security.\
312 s
= xstrprintf ("%s%c%s", auto_load_safe_path
, DIRNAME_SEPARATOR
, args
);
313 xfree (auto_load_safe_path
);
314 auto_load_safe_path
= s
;
316 auto_load_safe_path_vec_update ();
319 /* Implementation for filename_is_in_pattern overwriting the caller's FILENAME
323 filename_is_in_pattern_1 (char *filename
, char *pattern
)
325 size_t pattern_len
= strlen (pattern
);
326 size_t filename_len
= strlen (filename
);
329 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Matching file \"%s\" "
330 "to pattern \"%s\"\n"),
333 /* Trim trailing slashes ("/") from PATTERN. Even for "d:\" paths as
334 trailing slashes are trimmed also from FILENAME it still matches
336 while (pattern_len
&& IS_DIR_SEPARATOR (pattern
[pattern_len
- 1]))
338 pattern
[pattern_len
] = '\0';
340 /* Ensure auto_load_safe_path "/" matches any FILENAME. On MS-Windows
341 platform FILENAME even after gdb_realpath does not have to start with
342 IS_DIR_SEPARATOR character, such as the 'C:\x.exe' filename. */
343 if (pattern_len
== 0)
346 fprintf_unfiltered (gdb_stdlog
,
347 _("auto-load: Matched - empty pattern\n"));
353 /* Trim trailing slashes ("/"). PATTERN also has slashes trimmed the
354 same way so they will match. */
355 while (filename_len
&& IS_DIR_SEPARATOR (filename
[filename_len
- 1]))
357 filename
[filename_len
] = '\0';
358 if (filename_len
== 0)
361 fprintf_unfiltered (gdb_stdlog
,
362 _("auto-load: Not matched - pattern \"%s\".\n"),
367 if (gdb_filename_fnmatch (pattern
, filename
, FNM_FILE_NAME
| FNM_NOESCAPE
)
371 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Matched - file "
372 "\"%s\" to pattern \"%s\".\n"),
377 /* Trim trailing FILENAME component. */
378 while (filename_len
> 0 && !IS_DIR_SEPARATOR (filename
[filename_len
- 1]))
383 /* Return 1 if FILENAME matches PATTERN or if FILENAME resides in
384 a subdirectory of a directory that matches PATTERN. Return 0 otherwise.
385 gdb_realpath normalization is never done here. */
387 static ATTRIBUTE_PURE
int
388 filename_is_in_pattern (const char *filename
, const char *pattern
)
390 char *filename_copy
, *pattern_copy
;
392 filename_copy
= alloca (strlen (filename
) + 1);
393 strcpy (filename_copy
, filename
);
394 pattern_copy
= alloca (strlen (pattern
) + 1);
395 strcpy (pattern_copy
, pattern
);
397 return filename_is_in_pattern_1 (filename_copy
, pattern_copy
);
400 /* Return 1 if FILENAME belongs to one of directory components of
401 AUTO_LOAD_SAFE_PATH_VEC. Return 0 otherwise.
402 auto_load_safe_path_vec_update is never called.
403 *FILENAME_REALP may be updated by gdb_realpath of FILENAME - it has to be
404 freed by the caller. */
407 filename_is_in_auto_load_safe_path_vec (const char *filename
,
408 char **filename_realp
)
413 for (ix
= 0; VEC_iterate (char_ptr
, auto_load_safe_path_vec
, ix
, pattern
);
415 if (*filename_realp
== NULL
&& filename_is_in_pattern (filename
, pattern
))
420 if (*filename_realp
== NULL
)
422 *filename_realp
= gdb_realpath (filename
);
423 if (debug_auto_load
&& strcmp (*filename_realp
, filename
) != 0)
424 fprintf_unfiltered (gdb_stdlog
,
425 _("auto-load: Resolved "
426 "file \"%s\" as \"%s\".\n"),
427 filename
, *filename_realp
);
430 if (strcmp (*filename_realp
, filename
) != 0)
432 VEC_iterate (char_ptr
, auto_load_safe_path_vec
, ix
, pattern
); ++ix
)
433 if (filename_is_in_pattern (*filename_realp
, pattern
))
440 fprintf_unfiltered (gdb_stdlog
, _("auto-load: File \"%s\" matches "
441 "directory \"%s\".\n"),
449 /* Return 1 if FILENAME is located in one of the directories of
450 AUTO_LOAD_SAFE_PATH. Otherwise call warning and return 0. FILENAME does
451 not have to be an absolute path.
453 Existence of FILENAME is not checked. Function will still give a warning
454 even if the caller would quietly skip non-existing file in unsafe
458 file_is_auto_load_safe (const char *filename
, const char *debug_fmt
, ...)
460 char *filename_real
= NULL
;
461 struct cleanup
*back_to
;
462 static int advice_printed
= 0;
468 va_start (debug_args
, debug_fmt
);
469 vfprintf_unfiltered (gdb_stdlog
, debug_fmt
, debug_args
);
473 back_to
= make_cleanup (free_current_contents
, &filename_real
);
475 if (filename_is_in_auto_load_safe_path_vec (filename
, &filename_real
))
477 do_cleanups (back_to
);
481 auto_load_safe_path_vec_update ();
482 if (filename_is_in_auto_load_safe_path_vec (filename
, &filename_real
))
484 do_cleanups (back_to
);
488 warning (_("File \"%s\" auto-loading has been declined by your "
489 "`auto-load safe-path' set to \"%s\"."),
490 filename_real
, auto_load_safe_path
);
494 const char *homedir
= getenv ("HOME");
499 homeinit
= xstrprintf ("%s/%s", homedir
, gdbinit
);
500 make_cleanup (xfree
, homeinit
);
502 printf_filtered (_("\
503 To enable execution of this file add\n\
504 \tadd-auto-load-safe-path %s\n\
505 line to your configuration file \"%s\".\n\
506 To completely disable this security protection add\n\
507 \tset auto-load safe-path /\n\
508 line to your configuration file \"%s\".\n\
509 For more information about this security protection see the\n\
510 \"Auto-loading safe path\" section in the GDB manual. E.g., run from the shell:\n\
511 \tinfo \"(gdb)Auto-loading safe path\"\n"),
512 filename_real
, homeinit
, homeinit
);
516 do_cleanups (back_to
);
520 /* Definition of script language for GDB canned sequences of commands. */
522 static const struct script_language script_language_gdb
=
526 auto_load_gdb_scripts_enabled
,
527 source_gdb_script_for_objfile
531 source_gdb_script_for_objfile (struct objfile
*objfile
, FILE *file
,
532 const char *filename
)
534 volatile struct gdb_exception e
;
536 TRY_CATCH (e
, RETURN_MASK_ALL
)
538 script_from_file (file
, filename
);
540 exception_print (gdb_stderr
, e
);
543 /* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
544 the same script. There's no point in loading the script multiple times,
545 and there can be a lot of objfiles and scripts, so we keep track of scripts
548 struct auto_load_pspace_info
550 /* For each program space we keep track of loaded scripts. */
551 struct htab
*loaded_scripts
;
553 /* Non-zero if we've issued the warning about an auto-load script not being
554 found. We only want to issue this warning once. */
555 int script_not_found_warning_printed
;
558 /* Objects of this type are stored in the loaded script hash table. */
562 /* Name as provided by the objfile. */
565 /* Full path name or NULL if script wasn't found (or was otherwise
567 const char *full_path
;
569 /* Non-zero if this script has been loaded. */
572 const struct script_language
*language
;
575 /* Per-program-space data key. */
576 static const struct program_space_data
*auto_load_pspace_data
;
579 auto_load_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
581 struct auto_load_pspace_info
*info
= arg
;
583 if (info
->loaded_scripts
)
584 htab_delete (info
->loaded_scripts
);
588 /* Get the current autoload data. If none is found yet, add it now. This
589 function always returns a valid object. */
591 static struct auto_load_pspace_info
*
592 get_auto_load_pspace_data (struct program_space
*pspace
)
594 struct auto_load_pspace_info
*info
;
596 info
= program_space_data (pspace
, auto_load_pspace_data
);
599 info
= XZALLOC (struct auto_load_pspace_info
);
600 set_program_space_data (pspace
, auto_load_pspace_data
, info
);
606 /* Hash function for the loaded script hash. */
609 hash_loaded_script_entry (const void *data
)
611 const struct loaded_script
*e
= data
;
613 return htab_hash_string (e
->name
) ^ htab_hash_pointer (e
->language
);
616 /* Equality function for the loaded script hash. */
619 eq_loaded_script_entry (const void *a
, const void *b
)
621 const struct loaded_script
*ea
= a
;
622 const struct loaded_script
*eb
= b
;
624 return strcmp (ea
->name
, eb
->name
) == 0 && ea
->language
== eb
->language
;
627 /* Initialize the table to track loaded scripts.
628 Each entry is hashed by the full path name. */
631 init_loaded_scripts_info (struct auto_load_pspace_info
*pspace_info
)
633 /* Choose 31 as the starting size of the hash table, somewhat arbitrarily.
634 Space for each entry is obtained with one malloc so we can free them
637 pspace_info
->loaded_scripts
= htab_create (31,
638 hash_loaded_script_entry
,
639 eq_loaded_script_entry
,
642 pspace_info
->script_not_found_warning_printed
= FALSE
;
645 /* Wrapper on get_auto_load_pspace_data to also allocate the hash table
646 for loading scripts. */
648 struct auto_load_pspace_info
*
649 get_auto_load_pspace_data_for_loading (struct program_space
*pspace
)
651 struct auto_load_pspace_info
*info
;
653 info
= get_auto_load_pspace_data (pspace
);
654 if (info
->loaded_scripts
== NULL
)
655 init_loaded_scripts_info (info
);
660 /* Add script NAME in LANGUAGE to hash table of PSPACE_INFO. LOADED 1 if the
661 script has been (is going to) be loaded, 0 otherwise (such as if it has not
662 been found). FULL_PATH is NULL if the script wasn't found. The result is
663 true if the script was already in the hash table. */
666 maybe_add_script (struct auto_load_pspace_info
*pspace_info
, int loaded
,
667 const char *name
, const char *full_path
,
668 const struct script_language
*language
)
670 struct htab
*htab
= pspace_info
->loaded_scripts
;
671 struct loaded_script
**slot
, entry
;
675 entry
.language
= language
;
676 slot
= (struct loaded_script
**) htab_find_slot (htab
, &entry
, INSERT
);
677 in_hash_table
= *slot
!= NULL
;
679 /* If this script is not in the hash table, add it. */
685 /* Allocate all space in one chunk so it's easier to free. */
686 *slot
= xmalloc (sizeof (**slot
)
688 + (full_path
!= NULL
? (strlen (full_path
) + 1) : 0));
689 p
= ((char*) *slot
) + sizeof (**slot
);
692 if (full_path
!= NULL
)
695 strcpy (p
, full_path
);
696 (*slot
)->full_path
= p
;
699 (*slot
)->full_path
= NULL
;
700 (*slot
)->loaded
= loaded
;
701 (*slot
)->language
= language
;
704 return in_hash_table
;
707 /* Clear the table of loaded section scripts. */
710 clear_section_scripts (void)
712 struct program_space
*pspace
= current_program_space
;
713 struct auto_load_pspace_info
*info
;
715 info
= program_space_data (pspace
, auto_load_pspace_data
);
716 if (info
!= NULL
&& info
->loaded_scripts
!= NULL
)
718 htab_delete (info
->loaded_scripts
);
719 info
->loaded_scripts
= NULL
;
720 info
->script_not_found_warning_printed
= FALSE
;
724 /* Look for the auto-load script in LANGUAGE associated with OBJFILE where
725 OBJFILE's gdb_realpath is REALNAME and load it. Return 1 if we found any
726 matching script, return 0 otherwise. */
729 auto_load_objfile_script_1 (struct objfile
*objfile
, const char *realname
,
730 const struct script_language
*language
)
732 char *filename
, *debugfile
;
735 struct cleanup
*cleanups
;
737 len
= strlen (realname
);
738 filename
= xmalloc (len
+ strlen (language
->suffix
) + 1);
739 memcpy (filename
, realname
, len
);
740 strcpy (filename
+ len
, language
->suffix
);
742 cleanups
= make_cleanup (xfree
, filename
);
744 input
= gdb_fopen_cloexec (filename
, "r");
745 debugfile
= filename
;
747 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Attempted file \"%s\" %s.\n"),
748 debugfile
, input
? _("exists") : _("does not exist"));
756 /* Also try the same file in a subdirectory of gdb's data
759 vec
= auto_load_expand_dir_vars (auto_load_dir
);
760 make_cleanup_free_char_ptr_vec (vec
);
763 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Searching 'set auto-load "
764 "scripts-directory' path \"%s\".\n"),
767 for (ix
= 0; VEC_iterate (char_ptr
, vec
, ix
, dir
); ++ix
)
769 debugfile
= xmalloc (strlen (dir
) + strlen (filename
) + 1);
770 strcpy (debugfile
, dir
);
772 /* FILENAME is absolute, so we don't need a "/" here. */
773 strcat (debugfile
, filename
);
775 make_cleanup (xfree
, debugfile
);
776 input
= gdb_fopen_cloexec (debugfile
, "r");
778 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Attempted file "
781 input
? _("exists") : _("does not exist"));
790 struct auto_load_pspace_info
*pspace_info
;
792 make_cleanup_fclose (input
);
795 = file_is_auto_load_safe (filename
,
796 _("auto-load: Loading %s script \"%s\""
797 " by extension for objfile \"%s\".\n"),
798 language
->name
, filename
,
799 objfile_name (objfile
));
801 /* Add this script to the hash table too so
802 "info auto-load ${lang}-scripts" can print it. */
804 = get_auto_load_pspace_data_for_loading (current_program_space
);
805 maybe_add_script (pspace_info
, is_safe
, filename
, filename
, language
);
807 /* To preserve existing behaviour we don't check for whether the
808 script was already in the table, and always load it.
809 It's highly unlikely that we'd ever load it twice,
810 and these scripts are required to be idempotent under multiple
813 language
->source_script_for_objfile (objfile
, input
, debugfile
);
820 do_cleanups (cleanups
);
824 /* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
828 auto_load_objfile_script (struct objfile
*objfile
,
829 const struct script_language
*language
)
832 struct cleanup
*cleanups
;
834 /* Skip this script if support has not been compiled in or
835 auto-loading it has been disabled. */
837 || !language
->auto_load_enabled ())
840 realname
= gdb_realpath (objfile_name (objfile
));
841 cleanups
= make_cleanup (xfree
, realname
);
843 if (!auto_load_objfile_script_1 (objfile
, realname
, language
))
845 /* For Windows/DOS .exe executables, strip the .exe suffix, so that
846 FOO-gdb.gdb could be used for FOO.exe, and try again. */
848 size_t len
= strlen (realname
);
849 const size_t lexe
= sizeof (".exe") - 1;
851 if (len
> lexe
&& strcasecmp (realname
+ len
- lexe
, ".exe") == 0)
854 realname
[len
] = '\0';
856 fprintf_unfiltered (gdb_stdlog
, _("auto-load: Stripped .exe suffix, "
857 "retrying with \"%s\".\n"),
859 auto_load_objfile_script_1 (objfile
, realname
, language
);
863 do_cleanups (cleanups
);
866 /* Load scripts specified in OBJFILE.
867 START,END delimit a buffer containing a list of nul-terminated
869 SECTION_NAME is used in error messages.
871 Scripts are found per normal "source -s" command processing.
872 First the script is looked for in $cwd. If not found there the
873 source search path is used.
875 The section contains a list of path names of script files to load.
876 Each path is null-terminated. */
879 source_section_scripts (struct objfile
*objfile
, const char *section_name
,
880 const char *start
, const char *end
)
883 struct auto_load_pspace_info
*pspace_info
;
885 pspace_info
= get_auto_load_pspace_data_for_loading (current_program_space
);
887 for (p
= start
; p
< end
; ++p
)
892 int opened
, in_hash_table
;
893 struct cleanup
*back_to
;
894 /* At the moment we only support python scripts in .debug_gdb_scripts,
895 but that can change. */
896 const struct script_language
*language
= gdbpy_script_language_defn ();
900 warning (_("Invalid entry in %s section"), section_name
);
901 /* We could try various heuristics to find the next valid entry,
902 but it's safer to just punt. */
907 while (p
< end
&& *p
!= '\0')
911 char *buf
= alloca (p
- file
+ 1);
913 memcpy (buf
, file
, p
- file
);
914 buf
[p
- file
] = '\0';
915 warning (_("Non-null-terminated path in %s: %s"),
922 warning (_("Empty path in %s"), section_name
);
926 /* Skip this script if support has not been compiled in or
927 auto-loading it has been disabled. */
929 || !language
->auto_load_enabled ())
931 /* No message is printed, just skip it. */
935 opened
= find_and_open_script (file
, 1 /*search_path*/,
936 &stream
, &full_path
);
938 back_to
= make_cleanup (null_cleanup
, NULL
);
941 make_cleanup_fclose (stream
);
942 make_cleanup (xfree
, full_path
);
944 if (!file_is_auto_load_safe (full_path
,
945 _("auto-load: Loading %s script "
946 "\"%s\" from section \"%s\" of "
947 "objfile \"%s\".\n"),
948 language
->name
, full_path
, section_name
,
949 objfile_name (objfile
)))
956 /* If one script isn't found it's not uncommon for more to not be
957 found either. We don't want to print a message for each script,
958 too much noise. Instead, we print the warning once and tell the
959 user how to find the list of scripts that weren't loaded.
960 We don't throw an error, the program is still debuggable.
962 IWBN if complaints.c were more general-purpose. */
964 if (script_not_found_warning_print (pspace_info
))
965 warning (_("Missing auto-load scripts referenced in section %s\n\
967 Use `info auto-load %s-scripts [REGEXP]' to list them."),
968 section_name
, objfile_name (objfile
), language
->name
);
971 in_hash_table
= maybe_add_script (pspace_info
, opened
, file
, full_path
,
974 /* If this file is not currently loaded, load it. */
975 if (opened
&& !in_hash_table
)
977 gdb_assert (language
->source_script_for_objfile
!= NULL
);
978 language
->source_script_for_objfile (objfile
, stream
, full_path
);
981 do_cleanups (back_to
);
985 /* Load scripts specified in section SECTION_NAME of OBJFILE. */
988 auto_load_section_scripts (struct objfile
*objfile
, const char *section_name
)
990 bfd
*abfd
= objfile
->obfd
;
991 asection
*scripts_sect
;
992 bfd_byte
*data
= NULL
;
994 scripts_sect
= bfd_get_section_by_name (abfd
, section_name
);
995 if (scripts_sect
== NULL
)
998 if (!bfd_get_full_section_contents (abfd
, scripts_sect
, &data
))
999 warning (_("Couldn't read %s section of %s"),
1000 section_name
, bfd_get_filename (abfd
));
1003 struct cleanup
*cleanups
;
1004 char *p
= (char *) data
;
1006 cleanups
= make_cleanup (xfree
, p
);
1007 source_section_scripts (objfile
, section_name
, p
,
1008 p
+ bfd_get_section_size (scripts_sect
));
1009 do_cleanups (cleanups
);
1013 /* Load any auto-loaded scripts for OBJFILE. */
1016 load_auto_scripts_for_objfile (struct objfile
*objfile
)
1018 /* Return immediately if auto-loading has been globally disabled.
1019 This is to handle sequencing of operations during gdb startup.
1020 Also return immediately if OBJFILE is not actually a file. */
1021 if (!global_auto_load
|| (objfile
->flags
& OBJF_NOT_FILENAME
) != 0)
1024 /* Load any scripts for this objfile. e.g. foo-gdb.gdb, foo-gdb.py. */
1025 auto_load_objfile_script (objfile
, &script_language_gdb
);
1026 auto_load_objfile_script (objfile
, gdbpy_script_language_defn ());
1028 /* Load any scripts mentioned in AUTO_SECTION_NAME (.debug_gdb_scripts). */
1029 auto_load_section_scripts (objfile
, AUTO_SECTION_NAME
);
1032 /* This is a new_objfile observer callback to auto-load scripts.
1034 Two flavors of auto-loaded scripts are supported.
1035 1) based on the path to the objfile
1036 2) from .debug_gdb_scripts section */
1039 auto_load_new_objfile (struct objfile
*objfile
)
1043 /* OBJFILE is NULL when loading a new "main" symbol-file. */
1044 clear_section_scripts ();
1048 load_auto_scripts_for_objfile (objfile
);
1051 /* Collect scripts to be printed in a vec. */
1053 typedef struct loaded_script
*loaded_script_ptr
;
1054 DEF_VEC_P (loaded_script_ptr
);
1056 struct collect_matching_scripts_data
1058 VEC (loaded_script_ptr
) **scripts_p
;
1060 const struct script_language
*language
;
1063 /* Traversal function for htab_traverse.
1064 Collect the entry if it matches the regexp. */
1067 collect_matching_scripts (void **slot
, void *info
)
1069 struct loaded_script
*script
= *slot
;
1070 struct collect_matching_scripts_data
*data
= info
;
1072 if (script
->language
== data
->language
&& re_exec (script
->name
))
1073 VEC_safe_push (loaded_script_ptr
, *data
->scripts_p
, script
);
1081 print_script (struct loaded_script
*script
)
1083 struct ui_out
*uiout
= current_uiout
;
1084 struct cleanup
*chain
;
1086 chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1088 ui_out_field_string (uiout
, "loaded", script
->loaded
? "Yes" : "No");
1089 ui_out_field_string (uiout
, "script", script
->name
);
1090 ui_out_text (uiout
, "\n");
1092 /* If the name isn't the full path, print it too. */
1093 if (script
->full_path
!= NULL
1094 && strcmp (script
->name
, script
->full_path
) != 0)
1096 ui_out_text (uiout
, "\tfull name: ");
1097 ui_out_field_string (uiout
, "full_path", script
->full_path
);
1098 ui_out_text (uiout
, "\n");
1101 do_cleanups (chain
);
1104 /* Helper for info_auto_load_scripts to sort the scripts by name. */
1107 sort_scripts_by_name (const void *ap
, const void *bp
)
1109 const struct loaded_script
*a
= *(const struct loaded_script
**) ap
;
1110 const struct loaded_script
*b
= *(const struct loaded_script
**) bp
;
1112 return FILENAME_CMP (a
->name
, b
->name
);
1115 /* Special internal GDB value of auto_load_info_scripts's PATTERN identify
1116 the "info auto-load XXX" command has been executed through the general
1117 "info auto-load" invocation. Extra newline will be printed if needed. */
1118 char auto_load_info_scripts_pattern_nl
[] = "";
1120 /* Implementation for "info auto-load gdb-scripts"
1121 (and "info auto-load python-scripts"). List scripts in LANGUAGE matching
1122 PATTERN. FROM_TTY is the usual GDB boolean for user interactivity. */
1125 auto_load_info_scripts (char *pattern
, int from_tty
,
1126 const struct script_language
*language
)
1128 struct ui_out
*uiout
= current_uiout
;
1129 struct auto_load_pspace_info
*pspace_info
;
1130 struct cleanup
*script_chain
;
1131 VEC (loaded_script_ptr
) *scripts
;
1136 pspace_info
= get_auto_load_pspace_data (current_program_space
);
1138 if (pattern
&& *pattern
)
1140 char *re_err
= re_comp (pattern
);
1143 error (_("Invalid regexp: %s"), re_err
);
1150 /* We need to know the number of rows before we build the table.
1151 Plus we want to sort the scripts by name.
1152 So first traverse the hash table collecting the matching scripts. */
1154 scripts
= VEC_alloc (loaded_script_ptr
, 10);
1155 script_chain
= make_cleanup (VEC_cleanup (loaded_script_ptr
), &scripts
);
1157 if (pspace_info
!= NULL
&& pspace_info
->loaded_scripts
!= NULL
)
1159 struct collect_matching_scripts_data data
= { &scripts
, language
};
1161 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
1162 htab_traverse_noresize (pspace_info
->loaded_scripts
,
1163 collect_matching_scripts
, &data
);
1166 nr_scripts
= VEC_length (loaded_script_ptr
, scripts
);
1168 /* Table header shifted right by preceding "gdb-scripts: " would not match
1170 if (nr_scripts
> 0 && pattern
== auto_load_info_scripts_pattern_nl
)
1171 ui_out_text (uiout
, "\n");
1173 make_cleanup_ui_out_table_begin_end (uiout
, 2, nr_scripts
,
1174 "AutoLoadedScriptsTable");
1176 ui_out_table_header (uiout
, 7, ui_left
, "loaded", "Loaded");
1177 ui_out_table_header (uiout
, 70, ui_left
, "script", "Script");
1178 ui_out_table_body (uiout
);
1183 loaded_script_ptr script
;
1185 qsort (VEC_address (loaded_script_ptr
, scripts
),
1186 VEC_length (loaded_script_ptr
, scripts
),
1187 sizeof (loaded_script_ptr
), sort_scripts_by_name
);
1188 for (i
= 0; VEC_iterate (loaded_script_ptr
, scripts
, i
, script
); ++i
)
1189 print_script (script
);
1192 do_cleanups (script_chain
);
1194 if (nr_scripts
== 0)
1196 if (pattern
&& *pattern
)
1197 ui_out_message (uiout
, 0, "No auto-load scripts matching %s.\n",
1200 ui_out_message (uiout
, 0, "No auto-load scripts.\n");
1204 /* Wrapper for "info auto-load gdb-scripts". */
1207 info_auto_load_gdb_scripts (char *pattern
, int from_tty
)
1209 auto_load_info_scripts (pattern
, from_tty
, &script_language_gdb
);
1212 /* Implement 'info auto-load local-gdbinit'. */
1215 info_auto_load_local_gdbinit (char *args
, int from_tty
)
1217 if (auto_load_local_gdbinit_pathname
== NULL
)
1218 printf_filtered (_("Local .gdbinit file was not found.\n"));
1219 else if (auto_load_local_gdbinit_loaded
)
1220 printf_filtered (_("Local .gdbinit file \"%s\" has been loaded.\n"),
1221 auto_load_local_gdbinit_pathname
);
1223 printf_filtered (_("Local .gdbinit file \"%s\" has not been loaded.\n"),
1224 auto_load_local_gdbinit_pathname
);
1227 /* Return non-zero if SCRIPT_NOT_FOUND_WARNING_PRINTED of PSPACE_INFO was unset
1228 before calling this function. Always set SCRIPT_NOT_FOUND_WARNING_PRINTED
1232 script_not_found_warning_print (struct auto_load_pspace_info
*pspace_info
)
1234 int retval
= !pspace_info
->script_not_found_warning_printed
;
1236 pspace_info
->script_not_found_warning_printed
= 1;
1241 /* The only valid "set auto-load" argument is off|0|no|disable. */
1244 set_auto_load_cmd (char *args
, int from_tty
)
1246 struct cmd_list_element
*list
;
1249 /* See parse_binary_operation in use by the sub-commands. */
1251 length
= args
? strlen (args
) : 0;
1253 while (length
> 0 && (args
[length
- 1] == ' ' || args
[length
- 1] == '\t'))
1256 if (length
== 0 || (strncmp (args
, "off", length
) != 0
1257 && strncmp (args
, "0", length
) != 0
1258 && strncmp (args
, "no", length
) != 0
1259 && strncmp (args
, "disable", length
) != 0))
1260 error (_("Valid is only global 'set auto-load no'; "
1261 "otherwise check the auto-load sub-commands."));
1263 for (list
= *auto_load_set_cmdlist_get (); list
!= NULL
; list
= list
->next
)
1264 if (list
->var_type
== var_boolean
)
1266 gdb_assert (list
->type
== set_cmd
);
1267 do_set_command (args
, from_tty
, list
);
1271 /* Initialize "set auto-load " commands prefix and return it. */
1273 struct cmd_list_element
**
1274 auto_load_set_cmdlist_get (void)
1276 static struct cmd_list_element
*retval
;
1279 add_prefix_cmd ("auto-load", class_maintenance
, set_auto_load_cmd
, _("\
1280 Auto-loading specific settings.\n\
1281 Configure various auto-load-specific variables such as\n\
1282 automatic loading of Python scripts."),
1283 &retval
, "set auto-load ",
1284 1/*allow-unknown*/, &setlist
);
1289 /* Command "show auto-load" displays summary of all the current
1290 "show auto-load " settings. */
1293 show_auto_load_cmd (char *args
, int from_tty
)
1295 cmd_show_list (*auto_load_show_cmdlist_get (), from_tty
, "");
1298 /* Initialize "show auto-load " commands prefix and return it. */
1300 struct cmd_list_element
**
1301 auto_load_show_cmdlist_get (void)
1303 static struct cmd_list_element
*retval
;
1306 add_prefix_cmd ("auto-load", class_maintenance
, show_auto_load_cmd
, _("\
1307 Show auto-loading specific settings.\n\
1308 Show configuration of various auto-load-specific variables such as\n\
1309 automatic loading of Python scripts."),
1310 &retval
, "show auto-load ",
1311 0/*allow-unknown*/, &showlist
);
1316 /* Command "info auto-load" displays whether the various auto-load files have
1317 been loaded. This is reimplementation of cmd_show_list which inserts
1318 newlines at proper places. */
1321 info_auto_load_cmd (char *args
, int from_tty
)
1323 struct cmd_list_element
*list
;
1324 struct cleanup
*infolist_chain
;
1325 struct ui_out
*uiout
= current_uiout
;
1327 infolist_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "infolist");
1329 for (list
= *auto_load_info_cmdlist_get (); list
!= NULL
; list
= list
->next
)
1331 struct cleanup
*option_chain
1332 = make_cleanup_ui_out_tuple_begin_end (uiout
, "option");
1334 gdb_assert (!list
->prefixlist
);
1335 gdb_assert (list
->type
== not_set_cmd
);
1337 ui_out_field_string (uiout
, "name", list
->name
);
1338 ui_out_text (uiout
, ": ");
1339 cmd_func (list
, auto_load_info_scripts_pattern_nl
, from_tty
);
1341 /* Close the tuple. */
1342 do_cleanups (option_chain
);
1345 /* Close the tuple. */
1346 do_cleanups (infolist_chain
);
1349 /* Initialize "info auto-load " commands prefix and return it. */
1351 struct cmd_list_element
**
1352 auto_load_info_cmdlist_get (void)
1354 static struct cmd_list_element
*retval
;
1357 add_prefix_cmd ("auto-load", class_info
, info_auto_load_cmd
, _("\
1358 Print current status of auto-loaded files.\n\
1359 Print whether various files like Python scripts or .gdbinit files have been\n\
1360 found and/or loaded."),
1361 &retval
, "info auto-load ",
1362 0/*allow-unknown*/, &infolist
);
1367 void _initialize_auto_load (void);
1370 _initialize_auto_load (void)
1372 struct cmd_list_element
*cmd
;
1373 char *scripts_directory_help
;
1375 auto_load_pspace_data
1376 = register_program_space_data_with_cleanup (NULL
,
1377 auto_load_pspace_data_cleanup
);
1379 observer_attach_new_objfile (auto_load_new_objfile
);
1381 add_setshow_boolean_cmd ("gdb-scripts", class_support
,
1382 &auto_load_gdb_scripts
, _("\
1383 Enable or disable auto-loading of canned sequences of commands scripts."), _("\
1384 Show whether auto-loading of canned sequences of commands scripts is enabled."),
1386 If enabled, canned sequences of commands are loaded when the debugger reads\n\
1387 an executable or shared library.\n\
1388 This options has security implications for untrusted inferiors."),
1389 NULL
, show_auto_load_gdb_scripts
,
1390 auto_load_set_cmdlist_get (),
1391 auto_load_show_cmdlist_get ());
1393 add_cmd ("gdb-scripts", class_info
, info_auto_load_gdb_scripts
,
1394 _("Print the list of automatically loaded sequences of commands.\n\
1395 Usage: info auto-load gdb-scripts [REGEXP]"),
1396 auto_load_info_cmdlist_get ());
1398 add_setshow_boolean_cmd ("local-gdbinit", class_support
,
1399 &auto_load_local_gdbinit
, _("\
1400 Enable or disable auto-loading of .gdbinit script in current directory."), _("\
1401 Show whether auto-loading .gdbinit script in current directory is enabled."),
1403 If enabled, canned sequences of commands are loaded when debugger starts\n\
1404 from .gdbinit file in current directory. Such files are deprecated,\n\
1405 use a script associated with inferior executable file instead.\n\
1406 This options has security implications for untrusted inferiors."),
1407 NULL
, show_auto_load_local_gdbinit
,
1408 auto_load_set_cmdlist_get (),
1409 auto_load_show_cmdlist_get ());
1411 add_cmd ("local-gdbinit", class_info
, info_auto_load_local_gdbinit
,
1412 _("Print whether current directory .gdbinit file has been loaded.\n\
1413 Usage: info auto-load local-gdbinit"),
1414 auto_load_info_cmdlist_get ());
1416 auto_load_dir
= xstrdup (AUTO_LOAD_DIR
);
1417 scripts_directory_help
= xstrprintf (
1420 Automatically loaded Python scripts (named OBJFILE%s) and GDB scripts\n\
1421 (named OBJFILE%s) are located in one of the directories listed by this\n\
1424 GDBPY_AUTO_FILE_NAME
,
1427 Automatically loaded GDB scripts (named OBJFILE%s) are located in one\n\
1428 of the directories listed by this option.\n\
1433 This option is ignored for the kinds of scripts \
1434 having 'set auto-load ... off'.\n\
1435 Directories listed here need to be present also \
1436 in the 'set auto-load safe-path'\n\
1438 add_setshow_optional_filename_cmd ("scripts-directory", class_support
,
1439 &auto_load_dir
, _("\
1440 Set the list of directories from which to load auto-loaded scripts."), _("\
1441 Show the list of directories from which to load auto-loaded scripts."),
1442 scripts_directory_help
,
1443 set_auto_load_dir
, show_auto_load_dir
,
1444 auto_load_set_cmdlist_get (),
1445 auto_load_show_cmdlist_get ());
1446 xfree (scripts_directory_help
);
1448 auto_load_safe_path
= xstrdup (AUTO_LOAD_SAFE_PATH
);
1449 auto_load_safe_path_vec_update ();
1450 add_setshow_optional_filename_cmd ("safe-path", class_support
,
1451 &auto_load_safe_path
, _("\
1452 Set the list of files and directories that are safe for auto-loading."), _("\
1453 Show the list of files and directories that are safe for auto-loading."), _("\
1454 Various files loaded automatically for the 'set auto-load ...' options must\n\
1455 be located in one of the directories listed by this option. Warning will be\n\
1456 printed and file will not be used otherwise.\n\
1457 You can mix both directory and filename entries.\n\
1458 Setting this parameter to an empty list resets it to its default value.\n\
1459 Setting this parameter to '/' (without the quotes) allows any file\n\
1460 for the 'set auto-load ...' options. Each path entry can be also shell\n\
1461 wildcard pattern; '*' does not match directory separator.\n\
1462 This option is ignored for the kinds of files having 'set auto-load ... off'.\n\
1463 This options has security implications for untrusted inferiors."),
1464 set_auto_load_safe_path
,
1465 show_auto_load_safe_path
,
1466 auto_load_set_cmdlist_get (),
1467 auto_load_show_cmdlist_get ());
1468 observer_attach_gdb_datadir_changed (auto_load_gdb_datadir_changed
);
1470 cmd
= add_cmd ("add-auto-load-safe-path", class_support
,
1471 add_auto_load_safe_path
,
1472 _("Add entries to the list of directories from which it is safe "
1473 "to auto-load files.\n\
1474 See the commands 'set auto-load safe-path' and 'show auto-load safe-path' to\n\
1475 access the current full list setting."),
1477 set_cmd_completer (cmd
, filename_completer
);
1479 add_setshow_boolean_cmd ("auto-load", class_maintenance
,
1480 &debug_auto_load
, _("\
1481 Set auto-load verifications debugging."), _("\
1482 Show auto-load verifications debugging."), _("\
1483 When non-zero, debugging output for files of 'set auto-load ...'\n\
1485 NULL
, show_debug_auto_load
,
1486 &setdebuglist
, &showdebuglist
);