GDB (xrefs)
Loading...
Searching...
No Matches
auto-load.c
Go to the documentation of this file.
1/* GDB routines for supporting auto-loaded scripts.
2
3 Copyright (C) 2012-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21#include <ctype.h>
22#include "auto-load.h"
23#include "progspace.h"
24#include "gdbsupport/gdb_regex.h"
25#include "ui-out.h"
26#include "filenames.h"
27#include "command.h"
28#include "observable.h"
29#include "objfiles.h"
30#include "cli/cli-script.h"
31#include "gdbcmd.h"
32#include "cli/cli-cmds.h"
33#include "cli/cli-decode.h"
34#include "cli/cli-setshow.h"
35#include "readline/tilde.h"
36#include "completer.h"
37#include "fnmatch.h"
38#include "top.h"
39#include "gdbsupport/filestuff.h"
40#include "extension.h"
41#include "gdb/section-scripts.h"
42#include <algorithm>
43#include "gdbsupport/pathstuff.h"
44#include "cli/cli-style.h"
45
46/* The section to look in for auto-loaded scripts (in file formats that
47 support sections).
48 Each entry in this section is a record that begins with a leading byte
49 identifying the record type.
50 At the moment we only support one record type: A leading byte of 1,
51 followed by the path of a python script to load. */
52#define AUTO_SECTION_NAME ".debug_gdb_scripts"
53
54/* The section to look in for the name of a separate debug file. */
55#define DEBUGLINK_SECTION_NAME ".gnu_debuglink"
56
58 (struct auto_load_pspace_info *, struct objfile *objfile,
60 const char *section_name, unsigned offset);
61
63 (struct auto_load_pspace_info *, struct objfile *objfile,
65 const char *section_name, unsigned offset);
66
67/* See auto-load.h. */
68
69bool debug_auto_load = false;
70
71/* "show" command for the debug_auto_load configuration variable. */
72
73static void
74show_debug_auto_load (struct ui_file *file, int from_tty,
75 struct cmd_list_element *c, const char *value)
76{
77 gdb_printf (file, _("Debugging output for files "
78 "of 'set auto-load ...' is %s.\n"),
79 value);
80}
81
82/* User-settable option to enable/disable auto-loading of GDB_AUTO_FILE_NAME
83 scripts:
84 set auto-load gdb-scripts on|off
85 This is true if we should auto-load associated scripts when an objfile
86 is opened, false otherwise. */
87static bool auto_load_gdb_scripts = true;
88
89/* "show" command for the auto_load_gdb_scripts configuration variable. */
90
91static void
92show_auto_load_gdb_scripts (struct ui_file *file, int from_tty,
93 struct cmd_list_element *c, const char *value)
94{
95 gdb_printf (file, _("Auto-loading of canned sequences of commands "
96 "scripts is %s.\n"),
97 value);
98}
99
100/* See auto-load.h. */
101
102bool
104{
106}
107
108/* Internal-use flag to enable/disable auto-loading.
109 This is true if we should auto-load python code when an objfile is opened,
110 false otherwise.
111
112 Both auto_load_scripts && global_auto_load must be true to enable
113 auto-loading.
114
115 This flag exists to facilitate deferring auto-loading during start-up
116 until after ./.gdbinit has been read; it may augment the search directories
117 used to find the scripts. */
119
120/* Auto-load .gdbinit file from the current directory? */
122
123/* Absolute pathname to the current directory .gdbinit, if it exists. */
125
126/* if AUTO_LOAD_LOCAL_GDBINIT_PATHNAME has been loaded. */
128
129/* "show" command for the auto_load_local_gdbinit configuration variable. */
130
131static void
132show_auto_load_local_gdbinit (struct ui_file *file, int from_tty,
133 struct cmd_list_element *c, const char *value)
134{
135 gdb_printf (file, _("Auto-loading of .gdbinit script from current "
136 "directory is %s.\n"),
137 value);
138}
139
140/* Directory list from which to load auto-loaded scripts. It is not checked
141 for absolute paths but they are strongly recommended. It is initialized by
142 _initialize_auto_load. */
143static std::string auto_load_dir = AUTO_LOAD_DIR;
144
145/* "set" command for the auto_load_dir configuration variable. */
146
147static void
148set_auto_load_dir (const char *args, int from_tty, struct cmd_list_element *c)
149{
150 /* Setting the variable to "" resets it to the compile time defaults. */
151 if (auto_load_dir.empty ())
153}
154
155/* "show" command for the auto_load_dir configuration variable. */
156
157static void
158show_auto_load_dir (struct ui_file *file, int from_tty,
159 struct cmd_list_element *c, const char *value)
160{
161 gdb_printf (file, _("List of directories from which to load "
162 "auto-loaded scripts is %s.\n"),
163 value);
164}
165
166/* Directory list safe to hold auto-loaded files. It is not checked for
167 absolute paths but they are strongly recommended. It is initialized by
168 _initialize_auto_load. */
170
171/* Vector of directory elements of AUTO_LOAD_SAFE_PATH with each one normalized
172 by tilde_expand and possibly each entries has added its gdb_realpath
173 counterpart. */
174static std::vector<gdb::unique_xmalloc_ptr<char>> auto_load_safe_path_vec;
175
176/* Expand $datadir and $debugdir in STRING according to the rules of
177 substitute_path_component. */
178
179static std::vector<gdb::unique_xmalloc_ptr<char>>
180auto_load_expand_dir_vars (const char *string)
181{
182 char *s = xstrdup (string);
183 substitute_path_component (&s, "$datadir", gdb_datadir.c_str ());
184 substitute_path_component (&s, "$debugdir", debug_file_directory.c_str ());
185
186 if (debug_auto_load && strcmp (s, string) != 0)
187 auto_load_debug_printf ("Expanded $-variables to \"%s\".", s);
188
189 std::vector<gdb::unique_xmalloc_ptr<char>> dir_vec
190 = dirnames_to_char_ptr_vec (s);
191 xfree(s);
192
193 return dir_vec;
194}
195
196/* Update auto_load_safe_path_vec from current AUTO_LOAD_SAFE_PATH. */
197
198static void
200{
201 auto_load_debug_printf ("Updating directories of \"%s\".",
202 auto_load_safe_path.c_str ());
203
206 size_t len = auto_load_safe_path_vec.size ();
207
208 /* Apply tilde_expand and gdb_realpath to each AUTO_LOAD_SAFE_PATH_VEC
209 element. */
210 for (size_t i = 0; i < len; i++)
211 {
212 gdb::unique_xmalloc_ptr<char> &in_vec = auto_load_safe_path_vec[i];
213 gdb::unique_xmalloc_ptr<char> expanded (tilde_expand (in_vec.get ()));
214 gdb::unique_xmalloc_ptr<char> real_path = gdb_realpath (expanded.get ());
215
216 /* Ensure the current entry is at least tilde_expand-ed. ORIGINAL makes
217 sure we free the original string. */
218 gdb::unique_xmalloc_ptr<char> original = std::move (in_vec);
219 in_vec = std::move (expanded);
220
221 if (debug_auto_load)
222 {
223 if (strcmp (in_vec.get (), original.get ()) == 0)
224 auto_load_debug_printf ("Using directory \"%s\".",
225 in_vec.get ());
226 else
227 auto_load_debug_printf ("Resolved directory \"%s\" as \"%s\".",
228 original.get (), in_vec.get ());
229 }
230
231 /* If gdb_realpath returns a different content, append it. */
232 if (strcmp (real_path.get (), in_vec.get ()) != 0)
233 {
234 auto_load_debug_printf ("And canonicalized as \"%s\".",
235 real_path.get ());
236
237 auto_load_safe_path_vec.push_back (std::move (real_path));
238 }
239 }
240}
241
242/* Variable gdb_datadir has been set. Update content depending on $datadir. */
243
244static void
246{
248}
249
250/* "set" command for the auto_load_safe_path configuration variable. */
251
252static void
253set_auto_load_safe_path (const char *args,
254 int from_tty, struct cmd_list_element *c)
255{
256 /* Setting the variable to "" resets it to the compile time defaults. */
257 if (auto_load_safe_path.empty ())
259
261}
262
263/* "show" command for the auto_load_safe_path configuration variable. */
264
265static void
266show_auto_load_safe_path (struct ui_file *file, int from_tty,
267 struct cmd_list_element *c, const char *value)
268{
269 const char *cs;
270
271 /* Check if user has entered either "/" or for example ":".
272 But while more complicate content like ":/foo" would still also
273 permit any location do not hide those. */
274
275 for (cs = value; *cs && (*cs == DIRNAME_SEPARATOR || IS_DIR_SEPARATOR (*cs));
276 cs++);
277 if (*cs == 0)
278 gdb_printf (file, _("Auto-load files are safe to load from any "
279 "directory.\n"));
280 else
281 gdb_printf (file, _("List of directories from which it is safe to "
282 "auto-load files is %s.\n"),
283 value);
284}
285
286/* "add-auto-load-safe-path" command for the auto_load_safe_path configuration
287 variable. */
288
289static void
290add_auto_load_safe_path (const char *args, int from_tty)
291{
292 if (args == NULL || *args == 0)
293 error (_("\
294Directory argument required.\n\
295Use 'set auto-load safe-path /' for disabling the auto-load safe-path security.\
296"));
297
298 auto_load_safe_path = string_printf ("%s%c%s", auto_load_safe_path.c_str (),
299 DIRNAME_SEPARATOR, args);
300
302}
303
304/* "add-auto-load-scripts-directory" command for the auto_load_dir configuration
305 variable. */
306
307static void
308add_auto_load_dir (const char *args, int from_tty)
309{
310 if (args == NULL || *args == 0)
311 error (_("Directory argument required."));
312
313 auto_load_dir = string_printf ("%s%c%s", auto_load_dir.c_str (),
314 DIRNAME_SEPARATOR, args);
315}
316
317/* Implementation for filename_is_in_pattern overwriting the caller's FILENAME
318 and PATTERN. */
319
320static int
321filename_is_in_pattern_1 (char *filename, char *pattern)
322{
323 size_t pattern_len = strlen (pattern);
324 size_t filename_len = strlen (filename);
325
326 auto_load_debug_printf ("Matching file \"%s\" to pattern \"%s\"",
327 filename, pattern);
328
329 /* Trim trailing slashes ("/") from PATTERN. Even for "d:\" paths as
330 trailing slashes are trimmed also from FILENAME it still matches
331 correctly. */
332 while (pattern_len && IS_DIR_SEPARATOR (pattern[pattern_len - 1]))
333 pattern_len--;
334 pattern[pattern_len] = '\0';
335
336 /* Ensure auto_load_safe_path "/" matches any FILENAME. On MS-Windows
337 platform FILENAME even after gdb_realpath does not have to start with
338 IS_DIR_SEPARATOR character, such as the 'C:\x.exe' filename. */
339 if (pattern_len == 0)
340 {
341 auto_load_debug_printf ("Matched - empty pattern");
342 return 1;
343 }
344
345 for (;;)
346 {
347 /* Trim trailing slashes ("/"). PATTERN also has slashes trimmed the
348 same way so they will match. */
349 while (filename_len && IS_DIR_SEPARATOR (filename[filename_len - 1]))
350 filename_len--;
351 filename[filename_len] = '\0';
352 if (filename_len == 0)
353 {
354 auto_load_debug_printf ("Not matched - pattern \"%s\".", pattern);
355 return 0;
356 }
357
358 if (gdb_filename_fnmatch (pattern, filename, FNM_FILE_NAME | FNM_NOESCAPE)
359 == 0)
360 {
361 auto_load_debug_printf ("Matched - file \"%s\" to pattern \"%s\".",
362 filename, pattern);
363 return 1;
364 }
365
366 /* Trim trailing FILENAME component. */
367 while (filename_len > 0 && !IS_DIR_SEPARATOR (filename[filename_len - 1]))
368 filename_len--;
369 }
370}
371
372/* Return 1 if FILENAME matches PATTERN or if FILENAME resides in
373 a subdirectory of a directory that matches PATTERN. Return 0 otherwise.
374 gdb_realpath normalization is never done here. */
375
376static ATTRIBUTE_PURE int
377filename_is_in_pattern (const char *filename, const char *pattern)
378{
379 char *filename_copy, *pattern_copy;
380
381 filename_copy = (char *) alloca (strlen (filename) + 1);
382 strcpy (filename_copy, filename);
383 pattern_copy = (char *) alloca (strlen (pattern) + 1);
384 strcpy (pattern_copy, pattern);
385
386 return filename_is_in_pattern_1 (filename_copy, pattern_copy);
387}
388
389/* Return 1 if FILENAME belongs to one of directory components of
390 AUTO_LOAD_SAFE_PATH_VEC. Return 0 otherwise.
391 auto_load_safe_path_vec_update is never called.
392 *FILENAME_REALP may be updated by gdb_realpath of FILENAME. */
393
394static int
396 gdb::unique_xmalloc_ptr<char> *filename_realp)
397{
398 const char *pattern = NULL;
399
400 for (const gdb::unique_xmalloc_ptr<char> &p : auto_load_safe_path_vec)
401 if (*filename_realp == NULL && filename_is_in_pattern (filename, p.get ()))
402 {
403 pattern = p.get ();
404 break;
405 }
406
407 if (pattern == NULL)
408 {
409 if (*filename_realp == NULL)
410 {
411 *filename_realp = gdb_realpath (filename);
412 if (debug_auto_load && strcmp (filename_realp->get (), filename) != 0)
413 auto_load_debug_printf ("Resolved file \"%s\" as \"%s\".",
414 filename, filename_realp->get ());
415 }
416
417 if (strcmp (filename_realp->get (), filename) != 0)
418 for (const gdb::unique_xmalloc_ptr<char> &p : auto_load_safe_path_vec)
419 if (filename_is_in_pattern (filename_realp->get (), p.get ()))
420 {
421 pattern = p.get ();
422 break;
423 }
424 }
425
426 if (pattern != NULL)
427 {
428 auto_load_debug_printf ("File \"%s\" matches directory \"%s\".",
429 filename, pattern);
430 return 1;
431 }
432
433 return 0;
434}
435
436/* See auto-load.h. */
437
438bool
439file_is_auto_load_safe (const char *filename)
440{
441 gdb::unique_xmalloc_ptr<char> filename_real;
442 static bool advice_printed = false;
443
444 if (filename_is_in_auto_load_safe_path_vec (filename, &filename_real))
445 return true;
446
448 if (filename_is_in_auto_load_safe_path_vec (filename, &filename_real))
449 return true;
450
451 warning (_("File \"%ps\" auto-loading has been declined by your "
452 "`auto-load safe-path' set to \"%s\"."),
453 styled_string (file_name_style.style (), filename_real.get ()),
454 auto_load_safe_path.c_str ());
455
456 if (!advice_printed)
457 {
458 /* Find the existing home directory config file. */
459 struct stat buf;
460 std::string home_config = find_gdb_home_config_file (GDBINIT, &buf);
461 if (home_config.empty ())
462 {
463 /* The user doesn't have an existing home directory config file,
464 so we should suggest a suitable path for them to use. */
465 std::string config_dir_file
466 = get_standard_config_filename (GDBINIT);
467 if (!config_dir_file.empty ())
468 home_config = config_dir_file;
469 else
470 {
471 const char *homedir = getenv ("HOME");
472 if (homedir == nullptr)
473 homedir = "$HOME";
474 home_config = (std::string (homedir) + SLASH_STRING
475 + std::string (GDBINIT));
476 }
477 }
478
479 gdb_printf (_("\
480To enable execution of this file add\n\
481\tadd-auto-load-safe-path %s\n\
482line to your configuration file \"%ps\".\n\
483To completely disable this security protection add\n\
484\tset auto-load safe-path /\n\
485line to your configuration file \"%ps\".\n\
486For more information about this security protection see the\n\
487\"Auto-loading safe path\" section in the GDB manual. E.g., run from the shell:\n\
488\tinfo \"(gdb)Auto-loading safe path\"\n"),
489 filename_real.get (),
491 home_config.c_str ()),
493 home_config.c_str ()));
494 advice_printed = true;
495 }
496
497 return false;
498}
499
500/* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
501 the same script. There's no point in loading the script multiple times,
502 and there can be a lot of objfiles and scripts, so we keep track of scripts
503 loaded this way. */
504
506{
507 /* For each program space we keep track of loaded scripts, both when
508 specified as file names and as scripts to be executed directly. */
511
512 /* Non-zero if we've issued the warning about an auto-load script not being
513 supported. We only want to issue this warning once. */
515
516 /* Non-zero if we've issued the warning about an auto-load script not being
517 found. We only want to issue this warning once. */
519};
520
521/* Objects of this type are stored in the loaded_script hash table. */
522
524{
525 /* Name as provided by the objfile. */
526 const char *name;
527
528 /* Full path name or NULL if script wasn't found (or was otherwise
529 inaccessible), or NULL for loaded_script_texts. */
530 const char *full_path;
531
532 /* True if this script has been loaded. */
533 bool loaded;
534
536};
537
538/* Per-program-space data key. */
541
542/* Get the current autoload data. If none is found yet, add it now. This
543 function always returns a valid object. */
544
545static struct auto_load_pspace_info *
547{
548 struct auto_load_pspace_info *info;
549
550 info = auto_load_pspace_data.get (pspace);
551 if (info == NULL)
552 info = auto_load_pspace_data.emplace (pspace);
553
554 return info;
555}
556
557/* Hash function for the loaded script hash. */
558
559static hashval_t
560hash_loaded_script_entry (const void *data)
561{
562 const struct loaded_script *e = (const struct loaded_script *) data;
563
564 return htab_hash_string (e->name) ^ htab_hash_pointer (e->language);
565}
566
567/* Equality function for the loaded script hash. */
568
569static int
570eq_loaded_script_entry (const void *a, const void *b)
571{
572 const struct loaded_script *ea = (const struct loaded_script *) a;
573 const struct loaded_script *eb = (const struct loaded_script *) b;
574
575 return strcmp (ea->name, eb->name) == 0 && ea->language == eb->language;
576}
577
578/* Initialize the table to track loaded scripts.
579 Each entry is hashed by the full path name. */
580
581static void
583{
584 /* Choose 31 as the starting size of the hash table, somewhat arbitrarily.
585 Space for each entry is obtained with one malloc so we can free them
586 easily. */
587
588 pspace_info->loaded_script_files.reset
589 (htab_create (31,
592 xfree));
593 pspace_info->loaded_script_texts.reset
594 (htab_create (31,
597 xfree));
598
599 pspace_info->unsupported_script_warning_printed = false;
600 pspace_info->script_not_found_warning_printed = false;
601}
602
603/* Wrapper on get_auto_load_pspace_data to also allocate the hash table
604 for loading scripts. */
605
608{
609 struct auto_load_pspace_info *info;
610
611 info = get_auto_load_pspace_data (pspace);
612 if (info->loaded_script_files == NULL)
614
615 return info;
616}
617
618/* Add script file NAME in LANGUAGE to hash table of PSPACE_INFO.
619 LOADED is true if the script has been (is going to) be loaded, false
620 otherwise (such as if it has not been found).
621 FULL_PATH is NULL if the script wasn't found.
622
623 The result is true if the script was already in the hash table. */
624
625static bool
626maybe_add_script_file (struct auto_load_pspace_info *pspace_info, bool loaded,
627 const char *name, const char *full_path,
628 const struct extension_language_defn *language)
629{
630 struct htab *htab = pspace_info->loaded_script_files.get ();
631 struct loaded_script **slot, entry;
632
633 entry.name = name;
634 entry.language = language;
635 slot = (struct loaded_script **) htab_find_slot (htab, &entry, INSERT);
636 bool in_hash_table = *slot != NULL;
637
638 /* If this script is not in the hash table, add it. */
639
640 if (!in_hash_table)
641 {
642 char *p;
643
644 /* Allocate all space in one chunk so it's easier to free. */
645 *slot = ((struct loaded_script *)
646 xmalloc (sizeof (**slot)
647 + strlen (name) + 1
648 + (full_path != NULL ? (strlen (full_path) + 1) : 0)));
649 p = ((char*) *slot) + sizeof (**slot);
650 strcpy (p, name);
651 (*slot)->name = p;
652 if (full_path != NULL)
653 {
654 p += strlen (p) + 1;
655 strcpy (p, full_path);
656 (*slot)->full_path = p;
657 }
658 else
659 (*slot)->full_path = NULL;
660 (*slot)->loaded = loaded;
661 (*slot)->language = language;
662 }
663
664 return in_hash_table;
665}
666
667/* Add script contents NAME in LANGUAGE to hash table of PSPACE_INFO.
668 LOADED is true if the script has been (is going to) be loaded, false
669 otherwise (such as if it has not been found).
670
671 The result is true if the script was already in the hash table. */
672
673static bool
675 bool loaded, const char *name,
676 const struct extension_language_defn *language)
677{
678 struct htab *htab = pspace_info->loaded_script_texts.get ();
679 struct loaded_script **slot, entry;
680
681 entry.name = name;
682 entry.language = language;
683 slot = (struct loaded_script **) htab_find_slot (htab, &entry, INSERT);
684 bool in_hash_table = *slot != NULL;
685
686 /* If this script is not in the hash table, add it. */
687
688 if (!in_hash_table)
689 {
690 char *p;
691
692 /* Allocate all space in one chunk so it's easier to free. */
693 *slot = ((struct loaded_script *)
694 xmalloc (sizeof (**slot) + strlen (name) + 1));
695 p = ((char*) *slot) + sizeof (**slot);
696 strcpy (p, name);
697 (*slot)->name = p;
698 (*slot)->full_path = NULL;
699 (*slot)->loaded = loaded;
700 (*slot)->language = language;
701 }
702
703 return in_hash_table;
704}
705
706/* Clear the table of loaded section scripts. */
707
708static void
710{
711 struct program_space *pspace = current_program_space;
712 struct auto_load_pspace_info *info;
713
714 info = auto_load_pspace_data.get (pspace);
715 if (info != NULL && info->loaded_script_files != NULL)
716 auto_load_pspace_data.clear (pspace);
717}
718
719/* Look for the auto-load script in LANGUAGE associated with OBJFILE where
720 OBJFILE's gdb_realpath is REALNAME and load it. Return 1 if we found any
721 matching script, return 0 otherwise. */
722
723static int
724auto_load_objfile_script_1 (struct objfile *objfile, const char *realname,
725 const struct extension_language_defn *language)
726{
727 const char *debugfile;
728 int retval;
729 const char *suffix = ext_lang_auto_load_suffix (language);
730
731 std::string filename = std::string (realname) + suffix;
732
733 gdb_file_up input = gdb_fopen_cloexec (filename.c_str (), "r");
734 debugfile = filename.c_str ();
735
736 auto_load_debug_printf ("Attempted file \"%ps\" %s.",
737 styled_string (file_name_style.style (), debugfile),
738 input != nullptr ? "exists" : "does not exist");
739
740 std::string debugfile_holder;
741 if (!input)
742 {
743 /* Also try the same file in a subdirectory of gdb's data
744 directory. */
745
746 std::vector<gdb::unique_xmalloc_ptr<char>> vec
748
750 ("Searching 'set auto-load scripts-directory' path \"%s\".",
751 auto_load_dir.c_str ());
752
753 /* Convert Windows file name from c:/dir/file to /c/dir/file. */
754 if (HAS_DRIVE_SPEC (debugfile))
755 filename = (std::string("\\") + debugfile[0]
756 + STRIP_DRIVE_SPEC (debugfile));
757
758 for (const gdb::unique_xmalloc_ptr<char> &dir : vec)
759 {
760 /* FILENAME is absolute, so we don't need a "/" here. */
761 debugfile_holder = dir.get () + filename;
762 debugfile = debugfile_holder.c_str ();
763
764 input = gdb_fopen_cloexec (debugfile, "r");
765
766 auto_load_debug_printf ("Attempted file \"%ps\" %s.",
768 debugfile),
769 (input != nullptr
770 ? "exists"
771 : "does not exist"));
772
773 if (input != NULL)
774 break;
775 }
776 }
777
778 if (input)
779 {
780 struct auto_load_pspace_info *pspace_info;
781
783 ("Loading %s script \"%s\" by extension for objfile \"%s\".",
785
786 bool is_safe = file_is_auto_load_safe (debugfile);
787
788 /* Add this script to the hash table too so
789 "info auto-load ${lang}-scripts" can print it. */
790 pspace_info
792 maybe_add_script_file (pspace_info, is_safe, debugfile, debugfile,
793 language);
794
795 /* To preserve existing behaviour we don't check for whether the
796 script was already in the table, and always load it.
797 It's highly unlikely that we'd ever load it twice,
798 and these scripts are required to be idempotent under multiple
799 loads anyway. */
800 if (is_safe)
801 {
804
805 /* We shouldn't get here if support for the language isn't
806 compiled in. And the extension language is required to implement
807 this function. */
808 gdb_assert (sourcer != NULL);
809 sourcer (language, objfile, input.get (), debugfile);
810 }
811
812 retval = 1;
813 }
814 else
815 retval = 0;
816
817 return retval;
818}
819
820/* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
821 it. */
822
823void
825 const struct extension_language_defn *language)
826{
827 gdb::unique_xmalloc_ptr<char> realname
828 = gdb_realpath (objfile_name (objfile));
829
830 if (auto_load_objfile_script_1 (objfile, realname.get (), language))
831 return;
832
833 /* For Windows/DOS .exe executables, strip the .exe suffix, so that
834 FOO-gdb.gdb could be used for FOO.exe, and try again. */
835
836 size_t len = strlen (realname.get ());
837 const size_t lexe = sizeof (".exe") - 1;
838
839 if (len > lexe && strcasecmp (realname.get () + len - lexe, ".exe") == 0)
840 {
841 len -= lexe;
842 realname.get ()[len] = '\0';
843
845 ("Stripped .exe suffix, retrying with \"%s\".", realname.get ());
846
847 auto_load_objfile_script_1 (objfile, realname.get (), language);
848 return;
849 }
850
851 /* If OBJFILE is a separate debug file and its name does not match
852 the name given in the parent's .gnu_debuglink section, try to
853 find the auto-load script using the parent's path and the
854 debuglink name. */
855
857 if (parent != nullptr)
858 {
859 unsigned long crc32;
860 gdb::unique_xmalloc_ptr<char> debuglink
861 (bfd_get_debug_link_info (parent->obfd.get (), &crc32));
862
863 if (debuglink.get () != nullptr
864 && strcmp (debuglink.get (), lbasename (realname.get ())) != 0)
865 {
866 /* Replace the last component of the parent's path with the
867 debuglink name. */
868
869 std::string p_realname = gdb_realpath (objfile_name (parent)).get ();
870 size_t last = p_realname.find_last_of ('/');
871
872 if (last != std::string::npos)
873 {
874 p_realname.replace (last + 1, std::string::npos,
875 debuglink.get ());
876
878 ("Debug filename mismatch, retrying with \"%s\".",
879 p_realname.c_str ());
880
882 p_realname.c_str (), language);
883 }
884 }
885 }
886}
887
888/* Subroutine of source_section_scripts to simplify it.
889 Load FILE as a script in extension language LANGUAGE.
890 The script is from section SECTION_NAME in OBJFILE at offset OFFSET. */
891
892static void
894 struct objfile *objfile,
895 const struct extension_language_defn *language,
896 const char *section_name, unsigned int offset,
897 const char *file)
898{
900
901 /* Skip this script if support is not compiled in. */
903 if (sourcer == NULL)
904 {
905 /* We don't throw an error, the program is still debuggable. */
907 section_name, offset);
908 /* We *could* still try to open it, but there's no point. */
909 maybe_add_script_file (pspace_info, 0, file, NULL, language);
910 return;
911 }
912
913 /* Skip this script if auto-loading it has been disabled. */
915 {
916 /* No message is printed, just skip it. */
917 return;
918 }
919
920 gdb::optional<open_script> opened = find_and_open_script (file,
921 1 /*search_path*/);
922
923 if (opened)
924 {
926 ("Loading %s script \"%s\" from section \"%s\" of objfile \"%s\".",
927 ext_lang_name (language), opened->full_path.get (),
928 section_name, objfile_name (objfile));
929
930 if (!file_is_auto_load_safe (opened->full_path.get ()))
931 opened.reset ();
932 }
933 else
934 {
935 /* If one script isn't found it's not uncommon for more to not be
936 found either. We don't want to print a message for each script,
937 too much noise. Instead, we print the warning once and tell the
938 user how to find the list of scripts that weren't loaded.
939 We don't throw an error, the program is still debuggable.
940
941 IWBN if complaints.c were more general-purpose. */
942
944 section_name, offset);
945 }
946
947 bool in_hash_table
948 = maybe_add_script_file (pspace_info, bool (opened), file,
949 (opened ? opened->full_path.get (): NULL),
950 language);
951
952 /* If this file is not currently loaded, load it. */
953 if (opened && !in_hash_table)
954 sourcer (language, objfile, opened->stream.get (),
955 opened->full_path.get ());
956}
957
958/* Subroutine of source_section_scripts to simplify it.
959 Execute SCRIPT as a script in extension language LANG.
960 The script is from section SECTION_NAME in OBJFILE at offset OFFSET. */
961
962static void
964 struct objfile *objfile,
965 const struct extension_language_defn *language,
966 const char *section_name, unsigned int offset,
967 const char *script)
968{
970 const char *newline, *script_text;
971 const char *name;
972
973 /* The first line of the script is the name of the script.
974 It must not contain any kind of space character. */
975 name = NULL;
976 newline = strchr (script, '\n');
977 std::string name_holder;
978 if (newline != NULL)
979 {
980 const char *buf, *p;
981
982 /* Put the name in a buffer and validate it. */
983 name_holder = std::string (script, newline - script);
984 buf = name_holder.c_str ();
985 for (p = buf; *p != '\0'; ++p)
986 {
987 if (isspace (*p))
988 break;
989 }
990 /* We don't allow nameless scripts, they're not helpful to the user. */
991 if (p != buf && *p == '\0')
992 name = buf;
993 }
994 if (name == NULL)
995 {
996 /* We don't throw an error, the program is still debuggable. */
997 warning (_("\
998Missing/bad script name in entry at offset %u in section %s\n\
999of file %ps."),
1000 offset, section_name,
1003 return;
1004 }
1005 script_text = newline + 1;
1006
1007 /* Skip this script if support is not compiled in. */
1009 if (executor == NULL)
1010 {
1011 /* We don't throw an error, the program is still debuggable. */
1013 section_name, offset);
1014 maybe_add_script_text (pspace_info, 0, name, language);
1015 return;
1016 }
1017
1018 /* Skip this script if auto-loading it has been disabled. */
1020 {
1021 /* No message is printed, just skip it. */
1022 return;
1023 }
1024
1026 ("Loading %s script \"%s\" from section \"%s\" of objfile \"%s\".",
1027 ext_lang_name (language), name, section_name, objfile_name (objfile));
1028
1029 bool is_safe = file_is_auto_load_safe (objfile_name (objfile));
1030
1031 bool in_hash_table
1032 = maybe_add_script_text (pspace_info, is_safe, name, language);
1033
1034 /* If this file is not currently loaded, load it. */
1035 if (is_safe && !in_hash_table)
1036 executor (language, objfile, name, script_text);
1037}
1038
1039/* Load scripts specified in OBJFILE.
1040 START,END delimit a buffer containing a list of nul-terminated
1041 file names.
1042 SECTION_NAME is used in error messages.
1043
1044 Scripts specified as file names are found per normal "source -s" command
1045 processing. First the script is looked for in $cwd. If not found there
1046 the source search path is used.
1047
1048 The section contains a list of path names of script files to load or
1049 actual script contents. Each entry is nul-terminated. */
1050
1051static void
1052source_section_scripts (struct objfile *objfile, const char *section_name,
1053 const char *start, const char *end)
1054{
1055 const char *p;
1056 struct auto_load_pspace_info *pspace_info;
1057
1059
1060 for (p = start; p < end; ++p)
1061 {
1062 const char *entry;
1063 const struct extension_language_defn *language;
1064 unsigned int offset = p - start;
1065 int code = *p;
1066
1067 switch (code)
1068 {
1069 case SECTION_SCRIPT_ID_PYTHON_FILE:
1070 case SECTION_SCRIPT_ID_PYTHON_TEXT:
1072 break;
1073 case SECTION_SCRIPT_ID_SCHEME_FILE:
1074 case SECTION_SCRIPT_ID_SCHEME_TEXT:
1076 break;
1077 default:
1078 warning (_("Invalid entry in %s section"), section_name);
1079 /* We could try various heuristics to find the next valid entry,
1080 but it's safer to just punt. */
1081 return;
1082 }
1083 entry = ++p;
1084
1085 while (p < end && *p != '\0')
1086 ++p;
1087 if (p == end)
1088 {
1089 warning (_("Non-nul-terminated entry in %s at offset %u"),
1090 section_name, offset);
1091 /* Don't load/execute it. */
1092 break;
1093 }
1094
1095 switch (code)
1096 {
1097 case SECTION_SCRIPT_ID_PYTHON_FILE:
1098 case SECTION_SCRIPT_ID_SCHEME_FILE:
1099 if (p == entry)
1100 {
1101 warning (_("Empty entry in %s at offset %u"),
1102 section_name, offset);
1103 continue;
1104 }
1105 source_script_file (pspace_info, objfile, language,
1106 section_name, offset, entry);
1107 break;
1108 case SECTION_SCRIPT_ID_PYTHON_TEXT:
1109 case SECTION_SCRIPT_ID_SCHEME_TEXT:
1111 section_name, offset, entry);
1112 break;
1113 }
1114 }
1115}
1116
1117/* Load scripts specified in section SECTION_NAME of OBJFILE. */
1118
1119static void
1120auto_load_section_scripts (struct objfile *objfile, const char *section_name)
1121{
1122 bfd *abfd = objfile->obfd.get ();
1123 asection *scripts_sect;
1124 bfd_byte *data = NULL;
1125
1126 scripts_sect = bfd_get_section_by_name (abfd, section_name);
1127 if (scripts_sect == NULL
1128 || (bfd_section_flags (scripts_sect) & SEC_HAS_CONTENTS) == 0)
1129 return;
1130
1131 if (!bfd_get_full_section_contents (abfd, scripts_sect, &data))
1132 warning (_("Couldn't read %s section of %ps"),
1133 section_name,
1135 bfd_get_filename (abfd)));
1136 else
1137 {
1138 gdb::unique_xmalloc_ptr<bfd_byte> data_holder (data);
1139
1140 char *p = (char *) data;
1141 source_section_scripts (objfile, section_name, p,
1142 p + bfd_section_size (scripts_sect));
1143 }
1144}
1145
1146/* Load any auto-loaded scripts for OBJFILE. */
1147
1148void
1150{
1151 /* Return immediately if auto-loading has been globally disabled.
1152 This is to handle sequencing of operations during gdb startup.
1153 Also return immediately if OBJFILE was not created from a file
1154 on the local filesystem. */
1155 if (!global_auto_load
1156 || (objfile->flags & OBJF_NOT_FILENAME) != 0
1158 return;
1159
1160 /* Load any extension language scripts for this objfile.
1161 E.g., foo-gdb.gdb, foo-gdb.py. */
1163
1164 /* Load any scripts mentioned in AUTO_SECTION_NAME (.debug_gdb_scripts). */
1166}
1167
1168/* This is a new_objfile observer callback to auto-load scripts.
1169
1170 Two flavors of auto-loaded scripts are supported.
1171 1) based on the path to the objfile
1172 2) from .debug_gdb_scripts section */
1173
1174static void
1176{
1177 if (!objfile)
1178 {
1179 /* OBJFILE is NULL when loading a new "main" symbol-file. */
1181 return;
1182 }
1183
1185}
1186
1187/* Collect scripts to be printed in a vec. */
1188
1190{
1191 collect_matching_scripts_data (std::vector<loaded_script *> *scripts_p_,
1192 const extension_language_defn *language_)
1193 : scripts_p (scripts_p_), language (language_)
1194 {}
1195
1196 std::vector<loaded_script *> *scripts_p;
1198};
1199
1200/* Traversal function for htab_traverse.
1201 Collect the entry if it matches the regexp. */
1202
1203static int
1204collect_matching_scripts (void **slot, void *info)
1205{
1206 struct loaded_script *script = (struct loaded_script *) *slot;
1208 = (struct collect_matching_scripts_data *) info;
1209
1210 if (script->language == data->language && re_exec (script->name))
1211 data->scripts_p->push_back (script);
1212
1213 return 1;
1214}
1215
1216/* Print SCRIPT. */
1217
1218static void
1220{
1221 struct ui_out *uiout = current_uiout;
1222
1223 ui_out_emit_tuple tuple_emitter (uiout, NULL);
1224
1225 uiout->field_string ("loaded", script->loaded ? "Yes" : "No");
1226 uiout->field_string ("script", script->name);
1227 uiout->text ("\n");
1228
1229 /* If the name isn't the full path, print it too. */
1230 if (script->full_path != NULL
1231 && strcmp (script->name, script->full_path) != 0)
1232 {
1233 uiout->text ("\tfull name: ");
1234 uiout->field_string ("full_path", script->full_path);
1235 uiout->text ("\n");
1236 }
1237}
1238
1239/* Helper for info_auto_load_scripts to sort the scripts by name. */
1240
1241static bool
1243{
1244 return FILENAME_CMP (a->name, b->name) < 0;
1245}
1246
1247/* Special internal GDB value of auto_load_info_scripts's PATTERN identify
1248 the "info auto-load XXX" command has been executed through the general
1249 "info auto-load" invocation. Extra newline will be printed if needed. */
1251
1252/* Subroutine of auto_load_info_scripts to simplify it.
1253 Print SCRIPTS. */
1254
1255static void
1256print_scripts (const std::vector<loaded_script *> &scripts)
1257{
1258 for (loaded_script *script : scripts)
1259 print_script (script);
1260}
1261
1262/* Implementation for "info auto-load gdb-scripts"
1263 (and "info auto-load python-scripts"). List scripts in LANGUAGE matching
1264 PATTERN. FROM_TTY is the usual GDB boolean for user interactivity. */
1265
1266void
1267auto_load_info_scripts (const char *pattern, int from_tty,
1268 const struct extension_language_defn *language)
1269{
1270 struct ui_out *uiout = current_uiout;
1271 struct auto_load_pspace_info *pspace_info;
1272
1273 dont_repeat ();
1274
1276
1277 if (pattern && *pattern)
1278 {
1279 char *re_err = re_comp (pattern);
1280
1281 if (re_err)
1282 error (_("Invalid regexp: %s"), re_err);
1283 }
1284 else
1285 {
1286 re_comp ("");
1287 }
1288
1289 /* We need to know the number of rows before we build the table.
1290 Plus we want to sort the scripts by name.
1291 So first traverse the hash table collecting the matching scripts. */
1292
1293 std::vector<loaded_script *> script_files, script_texts;
1294
1295 if (pspace_info != NULL && pspace_info->loaded_script_files != NULL)
1296 {
1297 collect_matching_scripts_data data (&script_files, language);
1298
1299 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
1300 htab_traverse_noresize (pspace_info->loaded_script_files.get (),
1302
1303 std::sort (script_files.begin (), script_files.end (),
1305 }
1306
1307 if (pspace_info != NULL && pspace_info->loaded_script_texts != NULL)
1308 {
1309 collect_matching_scripts_data data (&script_texts, language);
1310
1311 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */
1312 htab_traverse_noresize (pspace_info->loaded_script_texts.get (),
1314
1315 std::sort (script_texts.begin (), script_texts.end (),
1317 }
1318
1319 int nr_scripts = script_files.size () + script_texts.size ();
1320
1321 /* Table header shifted right by preceding "gdb-scripts: " would not match
1322 its columns. */
1323 if (nr_scripts > 0 && pattern == auto_load_info_scripts_pattern_nl)
1324 uiout->text ("\n");
1325
1326 {
1327 ui_out_emit_table table_emitter (uiout, 2, nr_scripts,
1328 "AutoLoadedScriptsTable");
1329
1330 uiout->table_header (7, ui_left, "loaded", "Loaded");
1331 uiout->table_header (70, ui_left, "script", "Script");
1332 uiout->table_body ();
1333
1334 print_scripts (script_files);
1335 print_scripts (script_texts);
1336 }
1337
1338 if (nr_scripts == 0)
1339 {
1340 if (pattern && *pattern)
1341 uiout->message ("No auto-load scripts matching %s.\n", pattern);
1342 else
1343 uiout->message ("No auto-load scripts.\n");
1344 }
1345}
1346
1347/* Wrapper for "info auto-load gdb-scripts". */
1348
1349static void
1350info_auto_load_gdb_scripts (const char *pattern, int from_tty)
1351{
1352 auto_load_info_scripts (pattern, from_tty, &extension_language_gdb);
1353}
1354
1355/* Implement 'info auto-load local-gdbinit'. */
1356
1357static void
1358info_auto_load_local_gdbinit (const char *args, int from_tty)
1359{
1361 gdb_printf (_("Local .gdbinit file was not found.\n"));
1363 gdb_printf (_("Local .gdbinit file \"%ps\" has been loaded.\n"),
1366 else
1367 gdb_printf (_("Local .gdbinit file \"%ps\" has not been loaded.\n"),
1370}
1371
1372/* Print an "unsupported script" warning if it has not already been printed.
1373 The script is in language LANGUAGE at offset OFFSET in section SECTION_NAME
1374 of OBJFILE. */
1375
1376static void
1378 (struct auto_load_pspace_info *pspace_info,
1379 struct objfile *objfile, const struct extension_language_defn *language,
1380 const char *section_name, unsigned offset)
1381{
1382 if (!pspace_info->unsupported_script_warning_printed)
1383 {
1384 warning (_("\
1385Unsupported auto-load script at offset %u in section %s\n\
1386of file %ps.\n\
1387Use `info auto-load %s-scripts [REGEXP]' to list them."),
1388 offset, section_name,
1392 pspace_info->unsupported_script_warning_printed = true;
1393 }
1394}
1395
1396/* Return non-zero if SCRIPT_NOT_FOUND_WARNING_PRINTED of PSPACE_INFO was unset
1397 before calling this function. Always set SCRIPT_NOT_FOUND_WARNING_PRINTED
1398 of PSPACE_INFO. */
1399
1400static void
1402 (struct auto_load_pspace_info *pspace_info,
1403 struct objfile *objfile, const struct extension_language_defn *language,
1404 const char *section_name, unsigned offset)
1405{
1406 if (!pspace_info->script_not_found_warning_printed)
1407 {
1408 warning (_("\
1409Missing auto-load script at offset %u in section %s\n\
1410of file %ps.\n\
1411Use `info auto-load %s-scripts [REGEXP]' to list them."),
1412 offset, section_name,
1416 pspace_info->script_not_found_warning_printed = true;
1417 }
1418}
1419
1420/* The only valid "set auto-load" argument is off|0|no|disable. */
1421
1422static void
1423set_auto_load_cmd (const char *args, int from_tty)
1424{
1425 struct cmd_list_element *list;
1426 size_t length;
1427
1428 /* See parse_binary_operation in use by the sub-commands. */
1429
1430 length = args ? strlen (args) : 0;
1431
1432 while (length > 0 && (args[length - 1] == ' ' || args[length - 1] == '\t'))
1433 length--;
1434
1435 if (length == 0 || (strncmp (args, "off", length) != 0
1436 && strncmp (args, "0", length) != 0
1437 && strncmp (args, "no", length) != 0
1438 && strncmp (args, "disable", length) != 0))
1439 error (_("Valid is only global 'set auto-load no'; "
1440 "otherwise check the auto-load sub-commands."));
1441
1442 for (list = *auto_load_set_cmdlist_get (); list != NULL; list = list->next)
1443 if (list->var->type () == var_boolean)
1444 {
1445 gdb_assert (list->type == set_cmd);
1446 do_set_command (args, from_tty, list);
1447 }
1448}
1449
1450/* Initialize "set auto-load " commands prefix and return it. */
1451
1452struct cmd_list_element **
1454{
1455 static struct cmd_list_element *retval;
1456
1457 if (retval == NULL)
1459Auto-loading specific settings.\n\
1460Configure various auto-load-specific variables such as\n\
1461automatic loading of Python scripts."),
1462 &retval, 1/*allow-unknown*/, &setlist);
1463
1464 return &retval;
1465}
1466
1467/* Initialize "show auto-load " commands prefix and return it. */
1468
1469struct cmd_list_element **
1471{
1472 static struct cmd_list_element *retval;
1473
1474 if (retval == NULL)
1475 add_show_prefix_cmd ("auto-load", class_maintenance, _("\
1476Show auto-loading specific settings.\n\
1477Show configuration of various auto-load-specific variables such as\n\
1478automatic loading of Python scripts."),
1479 &retval, 0/*allow-unknown*/, &showlist);
1480
1481 return &retval;
1482}
1483
1484/* Command "info auto-load" displays whether the various auto-load files have
1485 been loaded. This is reimplementation of cmd_show_list which inserts
1486 newlines at proper places. */
1487
1488static void
1489info_auto_load_cmd (const char *args, int from_tty)
1490{
1491 struct cmd_list_element *list;
1492 struct ui_out *uiout = current_uiout;
1493
1494 ui_out_emit_tuple tuple_emitter (uiout, "infolist");
1495
1496 for (list = *auto_load_info_cmdlist_get (); list != NULL; list = list->next)
1497 {
1498 ui_out_emit_tuple option_emitter (uiout, "option");
1499
1500 gdb_assert (!list->is_prefix ());
1501 gdb_assert (list->type == not_set_cmd);
1502
1503 uiout->field_string ("name", list->name);
1504 uiout->text (": ");
1506 }
1507}
1508
1509/* Initialize "info auto-load " commands prefix and return it. */
1510
1511struct cmd_list_element **
1513{
1514 static struct cmd_list_element *retval;
1515
1516 if (retval == NULL)
1517 add_prefix_cmd ("auto-load", class_info, info_auto_load_cmd, _("\
1518Print current status of auto-loaded files.\n\
1519Print whether various files like Python scripts or .gdbinit files have been\n\
1520found and/or loaded."),
1521 &retval, 0/*allow-unknown*/, &infolist);
1522
1523 return &retval;
1524}
1525
1526/* See auto-load.h. */
1527
1529
1530void _initialize_auto_load ();
1531void
1533{
1534 struct cmd_list_element *cmd;
1535 gdb::unique_xmalloc_ptr<char> scripts_directory_help, gdb_name_help,
1536 python_name_help, guile_name_help;
1537 const char *suffix;
1538
1541 "auto-load");
1542 add_setshow_boolean_cmd ("gdb-scripts", class_support,
1544Enable or disable auto-loading of canned sequences of commands scripts."), _("\
1545Show whether auto-loading of canned sequences of commands scripts is enabled."),
1546 _("\
1547If enabled, canned sequences of commands are loaded when the debugger reads\n\
1548an executable or shared library.\n\
1549This option has security implications for untrusted inferiors."),
1553
1555 _("Print the list of automatically loaded sequences of commands.\n\
1556Usage: info auto-load gdb-scripts [REGEXP]"),
1558
1559 add_setshow_boolean_cmd ("local-gdbinit", class_support,
1561Enable or disable auto-loading of .gdbinit script in current directory."), _("\
1562Show whether auto-loading .gdbinit script in current directory is enabled."),
1563 _("\
1564If enabled, canned sequences of commands are loaded when debugger starts\n\
1565from .gdbinit file in current directory. Such files are deprecated,\n\
1566use a script associated with inferior executable file instead.\n\
1567This option has security implications for untrusted inferiors."),
1571
1573 _("Print whether current directory .gdbinit file has been loaded.\n\
1574Usage: info auto-load local-gdbinit"),
1576
1578 gdb_name_help
1579 = xstrprintf (_("\
1580GDB scripts: OBJFILE%s\n"),
1581 suffix);
1582 python_name_help = NULL;
1583#ifdef HAVE_PYTHON
1585 python_name_help
1586 = xstrprintf (_("\
1587Python scripts: OBJFILE%s\n"),
1588 suffix);
1589#endif
1590 guile_name_help = NULL;
1591#ifdef HAVE_GUILE
1593 guile_name_help
1594 = xstrprintf (_("\
1595Guile scripts: OBJFILE%s\n"),
1596 suffix);
1597#endif
1598 scripts_directory_help
1599 = xstrprintf (_("\
1600Automatically loaded scripts are located in one of the directories listed\n\
1601by this option.\n\
1602\n\
1603Script names:\n\
1604%s%s%s\
1605\n\
1606This option is ignored for the kinds of scripts \
1607having 'set auto-load ... off'.\n\
1608Directories listed here need to be present also \
1609in the 'set auto-load safe-path'\n\
1610option."),
1611 gdb_name_help.get (),
1612 python_name_help.get () ? python_name_help.get () : "",
1613 guile_name_help.get () ? guile_name_help.get () : "");
1614
1616 &auto_load_dir, _("\
1617Set the list of directories from which to load auto-loaded scripts."), _("\
1618Show the list of directories from which to load auto-loaded scripts."),
1619 scripts_directory_help.get (),
1625 &auto_load_safe_path, _("\
1626Set the list of files and directories that are safe for auto-loading."), _("\
1627Show the list of files and directories that are safe for auto-loading."), _("\
1628Various files loaded automatically for the 'set auto-load ...' options must\n\
1629be located in one of the directories listed by this option. Warning will be\n\
1630printed and file will not be used otherwise.\n\
1631You can mix both directory and filename entries.\n\
1632Setting this parameter to an empty list resets it to its default value.\n\
1633Setting this parameter to '/' (without the quotes) allows any file\n\
1634for the 'set auto-load ...' options. Each path entry can be also shell\n\
1635wildcard pattern; '*' does not match directory separator.\n\
1636This option is ignored for the kinds of files having 'set auto-load ... off'.\n\
1637This option has security implications for untrusted inferiors."),
1643 "auto-load");
1644
1645 cmd = add_cmd ("add-auto-load-safe-path", class_support,
1647 _("Add entries to the list of directories from which it is safe "
1648 "to auto-load files.\n\
1649See the commands 'set auto-load safe-path' and 'show auto-load safe-path' to\n\
1650access the current full list setting."),
1651 &cmdlist);
1653
1654 cmd = add_cmd ("add-auto-load-scripts-directory", class_support,
1656 _("Add entries to the list of directories from which to load "
1657 "auto-loaded scripts.\n\
1658See the commands 'set auto-load scripts-directory' and\n\
1659'show auto-load scripts-directory' to access the current full list setting."),
1660 &cmdlist);
1662
1664 &debug_auto_load, _("\
1665Set auto-load verifications debugging."), _("\
1666Show auto-load verifications debugging."), _("\
1667When non-zero, debugging output for files of 'set auto-load ...'\n\
1668is displayed."),
1671}
const char *const name
void * xmalloc(YYSIZE_T)
void xfree(void *)
int code
Definition ada-lex.l:688
static void add_auto_load_safe_path(const char *args, int from_tty)
Definition auto-load.c:290
static int filename_is_in_auto_load_safe_path_vec(const char *filename, gdb::unique_xmalloc_ptr< char > *filename_realp)
Definition auto-load.c:395
struct auto_load_pspace_info * get_auto_load_pspace_data_for_loading(struct program_space *pspace)
Definition auto-load.c:607
static void add_auto_load_dir(const char *args, int from_tty)
Definition auto-load.c:308
#define AUTO_SECTION_NAME
Definition auto-load.c:52
static std::string auto_load_dir
Definition auto-load.c:143
static int eq_loaded_script_entry(const void *a, const void *b)
Definition auto-load.c:570
static hashval_t hash_loaded_script_entry(const void *data)
Definition auto-load.c:560
static int filename_is_in_pattern_1(char *filename, char *pattern)
Definition auto-load.c:321
static void info_auto_load_cmd(const char *args, int from_tty)
Definition auto-load.c:1489
static void show_debug_auto_load(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition auto-load.c:74
static void show_auto_load_dir(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition auto-load.c:158
static void auto_load_section_scripts(struct objfile *objfile, const char *section_name)
Definition auto-load.c:1120
bool file_is_auto_load_safe(const char *filename)
Definition auto-load.c:439
static struct auto_load_pspace_info * get_auto_load_pspace_data(struct program_space *pspace)
Definition auto-load.c:546
static void auto_load_new_objfile(struct objfile *objfile)
Definition auto-load.c:1175
static void execute_script_contents(struct auto_load_pspace_info *pspace_info, struct objfile *objfile, const struct extension_language_defn *language, const char *section_name, unsigned int offset, const char *script)
Definition auto-load.c:963
void _initialize_auto_load()
Definition auto-load.c:1532
bool auto_load_gdb_scripts_enabled(const struct extension_language_defn *extlang)
Definition auto-load.c:103
struct cmd_list_element ** auto_load_info_cmdlist_get(void)
Definition auto-load.c:1512
static void show_auto_load_gdb_scripts(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition auto-load.c:92
static void info_auto_load_gdb_scripts(const char *pattern, int from_tty)
Definition auto-load.c:1350
static void set_auto_load_safe_path(const char *args, int from_tty, struct cmd_list_element *c)
Definition auto-load.c:253
void load_auto_scripts_for_objfile(struct objfile *objfile)
Definition auto-load.c:1149
static ATTRIBUTE_PURE int filename_is_in_pattern(const char *filename, const char *pattern)
Definition auto-load.c:377
bool auto_load_local_gdbinit_loaded
Definition auto-load.c:127
static void print_scripts(const std::vector< loaded_script * > &scripts)
Definition auto-load.c:1256
static void init_loaded_scripts_info(struct auto_load_pspace_info *pspace_info)
Definition auto-load.c:582
static bool maybe_add_script_file(struct auto_load_pspace_info *pspace_info, bool loaded, const char *name, const char *full_path, const struct extension_language_defn *language)
Definition auto-load.c:626
static int auto_load_objfile_script_1(struct objfile *objfile, const char *realname, const struct extension_language_defn *language)
Definition auto-load.c:724
static void print_script(struct loaded_script *script)
Definition auto-load.c:1219
char auto_load_info_scripts_pattern_nl[]
Definition auto-load.c:1250
static void show_auto_load_local_gdbinit(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition auto-load.c:132
static void set_auto_load_dir(const char *args, int from_tty, struct cmd_list_element *c)
Definition auto-load.c:148
static std::vector< gdb::unique_xmalloc_ptr< char > > auto_load_expand_dir_vars(const char *string)
Definition auto-load.c:180
static void set_auto_load_cmd(const char *args, int from_tty)
Definition auto-load.c:1423
static void source_script_file(struct auto_load_pspace_info *pspace_info, struct objfile *objfile, const struct extension_language_defn *language, const char *section_name, unsigned int offset, const char *file)
Definition auto-load.c:893
bool debug_auto_load
Definition auto-load.c:69
bool auto_load_local_gdbinit
Definition auto-load.c:121
void auto_load_info_scripts(const char *pattern, int from_tty, const struct extension_language_defn *language)
Definition auto-load.c:1267
static std::string auto_load_safe_path
Definition auto-load.c:169
bool global_auto_load
Definition auto-load.c:118
static void clear_section_scripts(void)
Definition auto-load.c:709
static const registry< program_space >::key< auto_load_pspace_info > auto_load_pspace_data
Definition auto-load.c:540
struct cmd_list_element ** auto_load_set_cmdlist_get(void)
Definition auto-load.c:1453
static std::vector< gdb::unique_xmalloc_ptr< char > > auto_load_safe_path_vec
Definition auto-load.c:174
static void maybe_print_unsupported_script_warning(struct auto_load_pspace_info *, struct objfile *objfile, const struct extension_language_defn *language, const char *section_name, unsigned offset)
Definition auto-load.c:1378
static void source_section_scripts(struct objfile *objfile, const char *section_name, const char *start, const char *end)
Definition auto-load.c:1052
static void show_auto_load_safe_path(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition auto-load.c:266
static bool sort_scripts_by_name(loaded_script *a, loaded_script *b)
Definition auto-load.c:1242
static void auto_load_gdb_datadir_changed(void)
Definition auto-load.c:245
static bool maybe_add_script_text(struct auto_load_pspace_info *pspace_info, bool loaded, const char *name, const struct extension_language_defn *language)
Definition auto-load.c:674
char * auto_load_local_gdbinit_pathname
Definition auto-load.c:124
static void info_auto_load_local_gdbinit(const char *args, int from_tty)
Definition auto-load.c:1358
struct cmd_list_element ** auto_load_show_cmdlist_get(void)
Definition auto-load.c:1470
gdb::observers::token auto_load_new_objfile_observer_token
Definition auto-load.c:1528
static int collect_matching_scripts(void **slot, void *info)
Definition auto-load.c:1204
static void maybe_print_script_not_found_warning(struct auto_load_pspace_info *, struct objfile *objfile, const struct extension_language_defn *language, const char *section_name, unsigned offset)
Definition auto-load.c:1402
static bool auto_load_gdb_scripts
Definition auto-load.c:87
static void auto_load_safe_path_vec_update(void)
Definition auto-load.c:199
void auto_load_objfile_script(struct objfile *objfile, const struct extension_language_defn *language)
Definition auto-load.c:824
#define auto_load_debug_printf(fmt,...)
Definition auto-load.h:40
ui_file_style style() const
Definition cli-style.c:169
void * get(unsigned key)
Definition registry.h:211
void field_string(const char *fldname, const char *string, const ui_file_style &style=ui_file_style())
Definition ui-out.c:511
void text(const char *string)
Definition ui-out.c:566
void table_header(int width, ui_align align, const std::string &col_name, const std::string &col_hdr)
Definition ui-out.c:363
void table_body()
Definition ui-out.c:376
void message(const char *format,...) ATTRIBUTE_PRINTF(2
Definition ui-out.c:774
struct cmd_list_element * showlist
Definition cli-cmds.c:125
struct cmd_list_element * infolist
Definition cli-cmds.c:89
struct cmd_list_element * cmdlist
Definition cli-cmds.c:85
struct cmd_list_element * setlist
Definition cli-cmds.c:117
struct cmd_list_element * showdebuglist
Definition cli-cmds.c:165
gdb::optional< open_script > find_and_open_script(const char *script_file, int search_path)
Definition cli-cmds.c:657
struct cmd_list_element * setdebuglist
Definition cli-cmds.c:163
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition cli-decode.c:233
set_show_commands add_setshow_optional_filename_cmd(const char *name, enum command_class theclass, std::string *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:934
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition cli-decode.c:117
struct cmd_list_element * add_show_prefix_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **subcommands, int allow_unknown, struct cmd_list_element **list)
Definition cli-decode.c:414
void cmd_func(struct cmd_list_element *cmd, const char *args, int from_tty)
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc, struct cmd_list_element **subcommands, int allow_unknown, struct cmd_list_element **list)
Definition cli-decode.c:357
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:739
@ not_set_cmd
Definition cli-decode.h:37
@ set_cmd
Definition cli-decode.h:38
void do_set_command(const char *arg, int from_tty, struct cmd_list_element *c)
cli_style_option file_name_style
void dont_repeat()
Definition top.c:809
@ var_boolean
Definition command.h:78
@ class_maintenance
Definition command.h:65
@ class_support
Definition command.h:58
@ class_info
Definition command.h:59
void filename_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition completer.c:204
#define AUTO_LOAD_DIR
Definition config.h:8
#define GDBINIT
Definition config.h:51
#define AUTO_LOAD_SAFE_PATH
Definition config.h:11
std::string debug_file_directory
Definition symfile.c:1355
EXTERN_C char * re_comp(const char *)
language
Definition defs.h:211
std::string gdb_datadir
Definition main.c:66
objfile_script_sourcer_func * ext_lang_objfile_script_sourcer(const struct extension_language_defn *extlang)
Definition extension.c:260
const char * ext_lang_name(const struct extension_language_defn *extlang)
Definition extension.c:207
bool ext_lang_auto_load_enabled(const struct extension_language_defn *extlang)
Definition extension.c:289
const struct extension_language_defn extension_language_gdb
Definition extension.c:53
const struct extension_language_defn * get_ext_lang_defn(enum extension_language lang)
Definition extension.c:99
void auto_load_ext_lang_scripts_for_objfile(struct objfile *objfile)
Definition extension.c:383
const char * ext_lang_auto_load_suffix(const struct extension_language_defn *extlang)
Definition extension.c:231
objfile_script_executor_func * ext_lang_objfile_script_executor(const struct extension_language_defn *extlang)
Definition extension.c:278
@ EXT_LANG_PYTHON
Definition extension.h:64
@ EXT_LANG_GUILE
Definition extension.h:65
@ EXT_LANG_GDB
Definition extension.h:63
void objfile_script_sourcer_func(const struct extension_language_defn *, struct objfile *, FILE *stream, const char *filename)
Definition extension.h:49
void objfile_script_executor_func(const struct extension_language_defn *, struct objfile *, const char *name, const char *script)
Definition extension.h:55
int is_target_filename(const char *name)
Definition gdb_bfd.c:207
observable< struct objfile * > new_objfile
observable gdb_datadir_changed
@ OBJF_NOT_FILENAME
const char * objfile_name(const struct objfile *objfile)
Definition objfiles.c:1308
struct program_space * current_program_space
Definition progspace.c:39
htab_up loaded_script_files
Definition auto-load.c:509
htab_up loaded_script_texts
Definition auto-load.c:510
bool script_not_found_warning_printed
Definition auto-load.c:518
bool unsupported_script_warning_printed
Definition auto-load.c:514
gdb::optional< setting > var
Definition cli-decode.h:236
__extension__ enum cmd_types type
Definition cli-decode.h:168
struct cmd_list_element * next
Definition cli-decode.h:113
const char * name
Definition cli-decode.h:116
bool is_prefix() const
Definition cli-decode.h:94
const struct extension_language_defn * language
Definition auto-load.c:1197
std::vector< loaded_script * > * scripts_p
Definition auto-load.c:1196
collect_matching_scripts_data(std::vector< loaded_script * > *scripts_p_, const extension_language_defn *language_)
Definition auto-load.c:1191
const char * name
Definition auto-load.c:526
const struct extension_language_defn * language
Definition auto-load.c:535
const char * full_path
Definition auto-load.c:530
const char * original_name
Definition objfiles.h:631
struct objfile * separate_debug_objfile_backlink
Definition objfiles.h:743
gdb_bfd_ref_ptr obfd
Definition objfiles.h:653
objfile_flags flags
Definition objfiles.h:637
Definition value.c:181
static styled_string_s * styled_string(const ui_file_style &style, const char *str, styled_string_s &&tmp={})
Definition ui-out.h:151
@ ui_left
Definition ui-out.h:45
#define current_uiout
Definition ui-out.h:40
int gdb_filename_fnmatch(const char *pattern, const char *string, int flags)
Definition utils.c:3420
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1865
void substitute_path_component(char **stringp, const char *from, const char *to)
Definition utils.c:3302