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