gdb/
[external/binutils.git] / gdb / auto-load.c
1 /* GDB routines for supporting auto-loaded scripts.
2
3    Copyright (C) 2012 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 "auto-load.h"
22 #include "progspace.h"
23 #include "python/python.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 "exceptions.h"
31 #include "cli/cli-script.h"
32 #include "gdbcmd.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
39 /* The suffix of per-objfile scripts to auto-load as non-Python command files.
40    E.g. When the program loads libfoo.so, look for libfoo-gdb.gdb.  */
41 #define GDB_AUTO_FILE_NAME "-gdb.gdb"
42
43 static void source_gdb_script_for_objfile (struct objfile *objfile, FILE *file,
44                                            const char *filename);
45
46 /* Value of the 'set debug auto-load' configuration variable.  */
47 static int debug_auto_load = 0;
48
49 /* "show" command for the debug_auto_load configuration variable.  */
50
51 static void
52 show_debug_auto_load (struct ui_file *file, int from_tty,
53                       struct cmd_list_element *c, const char *value)
54 {
55   fprintf_filtered (file, _("Debugging output for files "
56                             "of 'set auto-load ...' is %s.\n"),
57                     value);
58 }
59
60 /* User-settable option to enable/disable auto-loading of GDB_AUTO_FILE_NAME
61    scripts:
62    set auto-load gdb-scripts on|off
63    This is true if we should auto-load associated scripts when an objfile
64    is opened, false otherwise.  */
65 static int auto_load_gdb_scripts = 1;
66
67 /* "show" command for the auto_load_gdb_scripts configuration variable.  */
68
69 static void
70 show_auto_load_gdb_scripts (struct ui_file *file, int from_tty,
71                             struct cmd_list_element *c, const char *value)
72 {
73   fprintf_filtered (file, _("Auto-loading of canned sequences of commands "
74                             "scripts is %s.\n"),
75                     value);
76 }
77
78 /* Internal-use flag to enable/disable auto-loading.
79    This is true if we should auto-load python code when an objfile is opened,
80    false otherwise.
81
82    Both auto_load_scripts && global_auto_load must be true to enable
83    auto-loading.
84
85    This flag exists to facilitate deferring auto-loading during start-up
86    until after ./.gdbinit has been read; it may augment the search directories
87    used to find the scripts.  */
88 int global_auto_load = 1;
89
90 /* Auto-load .gdbinit file from the current directory?  */
91 int auto_load_local_gdbinit = 1;
92
93 /* Absolute pathname to the current directory .gdbinit, if it exists.  */
94 char *auto_load_local_gdbinit_pathname = NULL;
95
96 /* Boolean value if AUTO_LOAD_LOCAL_GDBINIT_PATHNAME has been loaded.  */
97 int auto_load_local_gdbinit_loaded = 0;
98
99 /* "show" command for the auto_load_local_gdbinit configuration variable.  */
100
101 static void
102 show_auto_load_local_gdbinit (struct ui_file *file, int from_tty,
103                               struct cmd_list_element *c, const char *value)
104 {
105   fprintf_filtered (file, _("Auto-loading of .gdbinit script from current "
106                             "directory is %s.\n"),
107                     value);
108 }
109
110 /* Directory list safe to hold auto-loaded files.  It is not checked for
111    absolute paths but they are strongly recommended.  It is initialized by
112    _initialize_auto_load.  */
113 static char *auto_load_safe_path;
114
115 /* Vector of directory elements of AUTO_LOAD_SAFE_PATH with each one normalized
116    by tilde_expand and possibly each entries has added its gdb_realpath
117    counterpart.  */
118 static VEC (char_ptr) *auto_load_safe_path_vec;
119
120 /* Update auto_load_safe_path_vec from current AUTO_LOAD_SAFE_PATH.  */
121
122 static void
123 auto_load_safe_path_vec_update (void)
124 {
125   VEC (char_ptr) *dir_vec = NULL;
126   unsigned len;
127   int ix;
128
129   if (debug_auto_load)
130     fprintf_unfiltered (gdb_stdlog,
131                         _("auto-load: Updating directories of \"%s\".\n"),
132                         auto_load_safe_path);
133
134   free_char_ptr_vec (auto_load_safe_path_vec);
135
136   auto_load_safe_path_vec = dirnames_to_char_ptr_vec (auto_load_safe_path);
137   len = VEC_length (char_ptr, auto_load_safe_path_vec);
138
139   /* Apply tilde_expand and gdb_realpath to each AUTO_LOAD_SAFE_PATH_VEC
140      element.  */
141   for (ix = 0; ix < len; ix++)
142     {
143       char *dir = VEC_index (char_ptr, auto_load_safe_path_vec, ix);
144       char *expanded = tilde_expand (dir);
145       char *real_path = gdb_realpath (expanded);
146
147       /* Ensure the current entry is at least tilde_expand-ed.  */
148       VEC_replace (char_ptr, auto_load_safe_path_vec, ix, expanded);
149
150       if (debug_auto_load)
151         {
152           if (strcmp (expanded, dir) == 0)
153             fprintf_unfiltered (gdb_stdlog,
154                                 _("auto-load: Using directory \"%s\".\n"),
155                                 expanded);
156           else
157             fprintf_unfiltered (gdb_stdlog,
158                                 _("auto-load: Resolved directory \"%s\" "
159                                   "as \"%s\".\n"),
160                                 dir, expanded);
161         }
162       xfree (dir);
163
164       /* If gdb_realpath returns a different content, append it.  */
165       if (strcmp (real_path, expanded) == 0)
166         xfree (real_path);
167       else
168         {
169           VEC_safe_push (char_ptr, auto_load_safe_path_vec, real_path);
170
171           if (debug_auto_load)
172             fprintf_unfiltered (gdb_stdlog,
173                                 _("auto-load: And canonicalized as \"%s\".\n"),
174                                 real_path);
175         }
176     }
177 }
178
179 /* "set" command for the auto_load_safe_path configuration variable.  */
180
181 static void
182 set_auto_load_safe_path (char *args, int from_tty, struct cmd_list_element *c)
183 {
184   if (auto_load_safe_path[0] == '\0')
185     {
186       xfree (auto_load_safe_path);
187       auto_load_safe_path = xstrdup (DEFAULT_AUTO_LOAD_SAFE_PATH);
188     }
189
190   auto_load_safe_path_vec_update ();
191 }
192
193 /* "show" command for the auto_load_safe_path configuration variable.  */
194
195 static void
196 show_auto_load_safe_path (struct ui_file *file, int from_tty,
197                           struct cmd_list_element *c, const char *value)
198 {
199   if (strcmp (value, "/") == 0)
200     fprintf_filtered (file, _("Auto-load files are safe to load from any "
201                               "directory.\n"));
202   else
203     fprintf_filtered (file, _("List of directories from which it is safe to "
204                               "auto-load files is %s.\n"),
205                       value);
206 }
207
208 /* "add-auto-load-safe-path" command for the auto_load_safe_path configuration
209    variable.  */
210
211 static void
212 add_auto_load_safe_path (char *args, int from_tty)
213 {
214   char *s;
215
216   if (args == NULL || *args == 0)
217     error (_("\
218 Directory argument required.\n\
219 Use 'set auto-load safe-path /' for disabling the auto-load safe-path security.\
220 "));
221
222   s = xstrprintf ("%s%c%s", auto_load_safe_path, DIRNAME_SEPARATOR, args);
223   xfree (auto_load_safe_path);
224   auto_load_safe_path = s;
225
226   auto_load_safe_path_vec_update ();
227 }
228
229 /* Return 1 if FILENAME is equal to DIR or if FILENAME belongs to the
230    subdirectory DIR.  Return 0 otherwise.  gdb_realpath normalization is never
231    done here.  */
232
233 static ATTRIBUTE_PURE int
234 filename_is_in_dir (const char *filename, const char *dir)
235 {
236   size_t dir_len = strlen (dir);
237
238   while (dir_len && IS_DIR_SEPARATOR (dir[dir_len - 1]))
239     dir_len--;
240
241   /* Ensure auto_load_safe_path "/" matches any FILENAME.  On MS-Windows
242      platform FILENAME even after gdb_realpath does not have to start with
243      IS_DIR_SEPARATOR character, such as the 'C:\x.exe' filename.  */
244   if (dir_len == 0)
245     return 1;
246
247   return (filename_ncmp (dir, filename, dir_len) == 0
248           && (IS_DIR_SEPARATOR (filename[dir_len])
249               || filename[dir_len] == '\0'));
250 }
251
252 /* Return 1 if FILENAME belongs to one of directory components of
253    AUTO_LOAD_SAFE_PATH_VEC.  Return 0 otherwise.
254    auto_load_safe_path_vec_update is never called.
255    *FILENAME_REALP may be updated by gdb_realpath of FILENAME - it has to be
256    freed by the caller.  */
257
258 static int
259 filename_is_in_auto_load_safe_path_vec (const char *filename,
260                                         char **filename_realp)
261 {
262   char *dir;
263   int ix;
264
265   for (ix = 0; VEC_iterate (char_ptr, auto_load_safe_path_vec, ix, dir); ++ix)
266     if (*filename_realp == NULL && filename_is_in_dir (filename, dir))
267       break;
268   
269   if (dir == NULL)
270     {
271       if (*filename_realp == NULL)
272         {
273           *filename_realp = gdb_realpath (filename);
274           if (debug_auto_load && strcmp (*filename_realp, filename) != 0)
275             fprintf_unfiltered (gdb_stdlog,
276                                 _("auto-load: Resolved "
277                                   "file \"%s\" as \"%s\".\n"),
278                                 filename, *filename_realp);
279         }
280
281       if (strcmp (*filename_realp, filename) != 0)
282         for (ix = 0; VEC_iterate (char_ptr, auto_load_safe_path_vec, ix, dir);
283              ++ix)
284           if (filename_is_in_dir (*filename_realp, dir))
285             break;
286     }
287
288   if (dir != NULL)
289     {
290       if (debug_auto_load)
291         fprintf_unfiltered (gdb_stdlog, _("auto-load: File \"%s\" matches "
292                                           "directory \"%s\".\n"),
293                             filename, dir);
294       return 1;
295     }
296
297   return 0;
298 }
299
300 /* Return 1 if FILENAME is located in one of the directories of
301    AUTO_LOAD_SAFE_PATH.  Otherwise call warning and return 0.  FILENAME does
302    not have to be an absolute path.
303
304    Existence of FILENAME is not checked.  Function will still give a warning
305    even if the caller would quietly skip non-existing file in unsafe
306    directory.  */
307
308 int
309 file_is_auto_load_safe (const char *filename, const char *debug_fmt, ...)
310 {
311   char *filename_real = NULL;
312   struct cleanup *back_to;
313
314   if (debug_auto_load)
315     {
316       va_list debug_args;
317
318       va_start (debug_args, debug_fmt);
319       vfprintf_unfiltered (gdb_stdlog, debug_fmt, debug_args);
320       va_end (debug_args);
321     }
322
323   back_to = make_cleanup (free_current_contents, &filename_real);
324
325   if (filename_is_in_auto_load_safe_path_vec (filename, &filename_real))
326     {
327       do_cleanups (back_to);
328       return 1;
329     }
330
331   auto_load_safe_path_vec_update ();
332   if (filename_is_in_auto_load_safe_path_vec (filename, &filename_real))
333     {
334       do_cleanups (back_to);
335       return 1;
336     }
337
338   warning (_("File \"%s\" auto-loading has been declined by your "
339              "`auto-load safe-path' set to \"%s\"."),
340            filename_real, auto_load_safe_path);
341
342   do_cleanups (back_to);
343   return 0;
344 }
345
346 /* Definition of script language for GDB canned sequences of commands.  */
347
348 static const struct script_language script_language_gdb
349   = { GDB_AUTO_FILE_NAME, source_gdb_script_for_objfile };
350
351 static void
352 source_gdb_script_for_objfile (struct objfile *objfile, FILE *file,
353                                const char *filename)
354 {
355   int is_safe;
356   struct auto_load_pspace_info *pspace_info;
357   volatile struct gdb_exception e;
358
359   is_safe = file_is_auto_load_safe (filename, _("auto-load: Loading canned "
360                                                 "sequences of commands script "
361                                                 "\"%s\" for objfile \"%s\".\n"),
362                                     filename, objfile->name);
363
364   /* Add this script to the hash table too so "info auto-load gdb-scripts"
365      can print it.  */
366   pspace_info = get_auto_load_pspace_data_for_loading (current_program_space);
367   maybe_add_script (pspace_info, is_safe, filename, filename,
368                     &script_language_gdb);
369
370   if (!is_safe)
371     return;
372
373   TRY_CATCH (e, RETURN_MASK_ALL)
374     {
375       script_from_file (file, filename);
376     }
377   exception_print (gdb_stderr, e);
378 }
379
380 /* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
381    the same script.  There's no point in loading the script multiple times,
382    and there can be a lot of objfiles and scripts, so we keep track of scripts
383    loaded this way.  */
384
385 struct auto_load_pspace_info
386 {
387   /* For each program space we keep track of loaded scripts.  */
388   struct htab *loaded_scripts;
389
390   /* Non-zero if we've issued the warning about an auto-load script not being
391      found.  We only want to issue this warning once.  */
392   int script_not_found_warning_printed;
393 };
394
395 /* Objects of this type are stored in the loaded script hash table.  */
396
397 struct loaded_script
398 {
399   /* Name as provided by the objfile.  */
400   const char *name;
401
402   /* Full path name or NULL if script wasn't found (or was otherwise
403      inaccessible).  */
404   const char *full_path;
405
406   /* Non-zero if this script has been loaded.  */
407   int loaded;
408
409   const struct script_language *language;
410 };
411
412 /* Per-program-space data key.  */
413 static const struct program_space_data *auto_load_pspace_data;
414
415 static void
416 auto_load_pspace_data_cleanup (struct program_space *pspace, void *arg)
417 {
418   struct auto_load_pspace_info *info;
419
420   info = program_space_data (pspace, auto_load_pspace_data);
421   if (info != NULL)
422     {
423       if (info->loaded_scripts)
424         htab_delete (info->loaded_scripts);
425       xfree (info);
426     }
427 }
428
429 /* Get the current autoload data.  If none is found yet, add it now.  This
430    function always returns a valid object.  */
431
432 static struct auto_load_pspace_info *
433 get_auto_load_pspace_data (struct program_space *pspace)
434 {
435   struct auto_load_pspace_info *info;
436
437   info = program_space_data (pspace, auto_load_pspace_data);
438   if (info == NULL)
439     {
440       info = XZALLOC (struct auto_load_pspace_info);
441       set_program_space_data (pspace, auto_load_pspace_data, info);
442     }
443
444   return info;
445 }
446
447 /* Hash function for the loaded script hash.  */
448
449 static hashval_t
450 hash_loaded_script_entry (const void *data)
451 {
452   const struct loaded_script *e = data;
453
454   return htab_hash_string (e->name) ^ htab_hash_pointer (e->language);
455 }
456
457 /* Equality function for the loaded script hash.  */
458
459 static int
460 eq_loaded_script_entry (const void *a, const void *b)
461 {
462   const struct loaded_script *ea = a;
463   const struct loaded_script *eb = b;
464
465   return strcmp (ea->name, eb->name) == 0 && ea->language == eb->language;
466 }
467
468 /* Initialize the table to track loaded scripts.
469    Each entry is hashed by the full path name.  */
470
471 static void
472 init_loaded_scripts_info (struct auto_load_pspace_info *pspace_info)
473 {
474   /* Choose 31 as the starting size of the hash table, somewhat arbitrarily.
475      Space for each entry is obtained with one malloc so we can free them
476      easily.  */
477
478   pspace_info->loaded_scripts = htab_create (31,
479                                              hash_loaded_script_entry,
480                                              eq_loaded_script_entry,
481                                              xfree);
482
483   pspace_info->script_not_found_warning_printed = FALSE;
484 }
485
486 /* Wrapper on get_auto_load_pspace_data to also allocate the hash table
487    for loading scripts.  */
488
489 struct auto_load_pspace_info *
490 get_auto_load_pspace_data_for_loading (struct program_space *pspace)
491 {
492   struct auto_load_pspace_info *info;
493
494   info = get_auto_load_pspace_data (pspace);
495   if (info->loaded_scripts == NULL)
496     init_loaded_scripts_info (info);
497
498   return info;
499 }
500
501 /* Add script NAME in LANGUAGE to hash table of PSPACE_INFO.  LOADED 1 if the
502    script has been (is going to) be loaded, 0 otherwise (such as if it has not
503    been found).  FULL_PATH is NULL if the script wasn't found.  The result is
504    true if the script was already in the hash table.  */
505
506 int
507 maybe_add_script (struct auto_load_pspace_info *pspace_info, int loaded,
508                   const char *name, const char *full_path,
509                   const struct script_language *language)
510 {
511   struct htab *htab = pspace_info->loaded_scripts;
512   struct loaded_script **slot, entry;
513   int in_hash_table;
514
515   entry.name = name;
516   entry.language = language;
517   slot = (struct loaded_script **) htab_find_slot (htab, &entry, INSERT);
518   in_hash_table = *slot != NULL;
519
520   /* If this script is not in the hash table, add it.  */
521
522   if (! in_hash_table)
523     {
524       char *p;
525
526       /* Allocate all space in one chunk so it's easier to free.  */
527       *slot = xmalloc (sizeof (**slot)
528                        + strlen (name) + 1
529                        + (full_path != NULL ? (strlen (full_path) + 1) : 0));
530       p = ((char*) *slot) + sizeof (**slot);
531       strcpy (p, name);
532       (*slot)->name = p;
533       if (full_path != NULL)
534         {
535           p += strlen (p) + 1;
536           strcpy (p, full_path);
537           (*slot)->full_path = p;
538         }
539       else
540         (*slot)->full_path = NULL;
541       (*slot)->loaded = loaded;
542       (*slot)->language = language;
543     }
544
545   return in_hash_table;
546 }
547
548 /* Clear the table of loaded section scripts.  */
549
550 static void
551 clear_section_scripts (void)
552 {
553   struct program_space *pspace = current_program_space;
554   struct auto_load_pspace_info *info;
555
556   info = program_space_data (pspace, auto_load_pspace_data);
557   if (info != NULL && info->loaded_scripts != NULL)
558     {
559       htab_delete (info->loaded_scripts);
560       info->loaded_scripts = NULL;
561       info->script_not_found_warning_printed = FALSE;
562     }
563 }
564
565 /* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
566    it.  */
567
568 void
569 auto_load_objfile_script (struct objfile *objfile,
570                           const struct script_language *language)
571 {
572   char *realname;
573   char *filename, *debugfile;
574   int len;
575   FILE *input;
576   struct cleanup *cleanups;
577
578   realname = gdb_realpath (objfile->name);
579   len = strlen (realname);
580   filename = xmalloc (len + strlen (language->suffix) + 1);
581   memcpy (filename, realname, len);
582   strcpy (filename + len, language->suffix);
583
584   cleanups = make_cleanup (xfree, filename);
585   make_cleanup (xfree, realname);
586
587   input = fopen (filename, "r");
588   debugfile = filename;
589
590   if (!input && debug_file_directory)
591     {
592       /* Also try the same file in the separate debug info directory.  */
593       debugfile = xmalloc (strlen (filename)
594                            + strlen (debug_file_directory) + 1);
595       strcpy (debugfile, debug_file_directory);
596       /* FILENAME is absolute, so we don't need a "/" here.  */
597       strcat (debugfile, filename);
598
599       make_cleanup (xfree, debugfile);
600       input = fopen (debugfile, "r");
601     }
602
603   if (!input && gdb_datadir)
604     {
605       /* Also try the same file in a subdirectory of gdb's data
606          directory.  */
607       debugfile = xmalloc (strlen (gdb_datadir) + strlen (filename)
608                            + strlen ("/auto-load") + 1);
609       strcpy (debugfile, gdb_datadir);
610       strcat (debugfile, "/auto-load");
611       /* FILENAME is absolute, so we don't need a "/" here.  */
612       strcat (debugfile, filename);
613
614       make_cleanup (xfree, debugfile);
615       input = fopen (debugfile, "r");
616     }
617
618   if (input)
619     {
620       make_cleanup_fclose (input);
621
622       /* To preserve existing behaviour we don't check for whether the
623          script was already in the table, and always load it.
624          It's highly unlikely that we'd ever load it twice,
625          and these scripts are required to be idempotent under multiple
626          loads anyway.  */
627       language->source_script_for_objfile (objfile, input, debugfile);
628     }
629
630   do_cleanups (cleanups);
631 }
632
633 /* Load any auto-loaded scripts for OBJFILE.  */
634
635 void
636 load_auto_scripts_for_objfile (struct objfile *objfile)
637 {
638   if (!global_auto_load)
639     return;
640
641   if (auto_load_gdb_scripts)
642     auto_load_objfile_script (objfile, &script_language_gdb);
643
644   gdbpy_load_auto_scripts_for_objfile (objfile);
645 }
646
647 /* This is a new_objfile observer callback to auto-load scripts.
648
649    Two flavors of auto-loaded scripts are supported.
650    1) based on the path to the objfile
651    2) from .debug_gdb_scripts section  */
652
653 static void
654 auto_load_new_objfile (struct objfile *objfile)
655 {
656   if (!objfile)
657     {
658       /* OBJFILE is NULL when loading a new "main" symbol-file.  */
659       clear_section_scripts ();
660       return;
661     }
662
663   load_auto_scripts_for_objfile (objfile);
664 }
665
666 /* Collect scripts to be printed in a vec.  */
667
668 typedef struct loaded_script *loaded_script_ptr;
669 DEF_VEC_P (loaded_script_ptr);
670
671 struct collect_matching_scripts_data
672 {
673   VEC (loaded_script_ptr) **scripts_p;
674
675   const struct script_language *language;
676 };
677
678 /* Traversal function for htab_traverse.
679    Collect the entry if it matches the regexp.  */
680
681 static int
682 collect_matching_scripts (void **slot, void *info)
683 {
684   struct loaded_script *script = *slot;
685   struct collect_matching_scripts_data *data = info;
686
687   if (script->language == data->language && re_exec (script->name))
688     VEC_safe_push (loaded_script_ptr, *data->scripts_p, script);
689
690   return 1;
691 }
692
693 /* Print SCRIPT.  */
694
695 static void
696 print_script (struct loaded_script *script)
697 {
698   struct ui_out *uiout = current_uiout;
699   struct cleanup *chain;
700
701   chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
702
703   ui_out_field_string (uiout, "loaded", script->loaded ? "Yes" : "No");
704   ui_out_field_string (uiout, "script", script->name);
705   ui_out_text (uiout, "\n");
706
707   /* If the name isn't the full path, print it too.  */
708   if (script->full_path != NULL
709       && strcmp (script->name, script->full_path) != 0)
710     {
711       ui_out_text (uiout, "\tfull name: ");
712       ui_out_field_string (uiout, "full_path", script->full_path);
713       ui_out_text (uiout, "\n");
714     }
715
716   do_cleanups (chain);
717 }
718
719 /* Helper for info_auto_load_scripts to sort the scripts by name.  */
720
721 static int
722 sort_scripts_by_name (const void *ap, const void *bp)
723 {
724   const struct loaded_script *a = *(const struct loaded_script **) ap;
725   const struct loaded_script *b = *(const struct loaded_script **) bp;
726
727   return FILENAME_CMP (a->name, b->name);
728 }
729
730 /* Special internal GDB value of auto_load_info_scripts's PATTERN identify
731    the "info auto-load XXX" command has been executed through the general
732    "info auto-load" invocation.  Extra newline will be printed if needed.  */
733 char auto_load_info_scripts_pattern_nl[] = "";
734
735 /* Implementation for "info auto-load gdb-scripts"
736    (and "info auto-load python-scripts").  List scripts in LANGUAGE matching
737    PATTERN.  FROM_TTY is the usual GDB boolean for user interactivity.  */
738
739 void
740 auto_load_info_scripts (char *pattern, int from_tty,
741                         const struct script_language *language)
742 {
743   struct ui_out *uiout = current_uiout;
744   struct auto_load_pspace_info *pspace_info;
745   struct cleanup *script_chain;
746   VEC (loaded_script_ptr) *scripts;
747   int nr_scripts;
748
749   dont_repeat ();
750
751   pspace_info = get_auto_load_pspace_data (current_program_space);
752
753   if (pattern && *pattern)
754     {
755       char *re_err = re_comp (pattern);
756
757       if (re_err)
758         error (_("Invalid regexp: %s"), re_err);
759     }
760   else
761     {
762       re_comp ("");
763     }
764
765   /* We need to know the number of rows before we build the table.
766      Plus we want to sort the scripts by name.
767      So first traverse the hash table collecting the matching scripts.  */
768
769   scripts = VEC_alloc (loaded_script_ptr, 10);
770   script_chain = make_cleanup (VEC_cleanup (loaded_script_ptr), &scripts);
771
772   if (pspace_info != NULL && pspace_info->loaded_scripts != NULL)
773     {
774       struct collect_matching_scripts_data data = { &scripts, language };
775
776       immediate_quit++;
777       /* Pass a pointer to scripts as VEC_safe_push can realloc space.  */
778       htab_traverse_noresize (pspace_info->loaded_scripts,
779                               collect_matching_scripts, &data);
780       immediate_quit--;
781     }
782
783   nr_scripts = VEC_length (loaded_script_ptr, scripts);
784
785   /* Table header shifted right by preceding "gdb-scripts:  " would not match
786      its columns.  */
787   if (nr_scripts > 0 && pattern == auto_load_info_scripts_pattern_nl)
788     ui_out_text (uiout, "\n");
789
790   make_cleanup_ui_out_table_begin_end (uiout, 2, nr_scripts,
791                                        "AutoLoadedScriptsTable");
792
793   ui_out_table_header (uiout, 7, ui_left, "loaded", "Loaded");
794   ui_out_table_header (uiout, 70, ui_left, "script", "Script");
795   ui_out_table_body (uiout);
796
797   if (nr_scripts > 0)
798     {
799       int i;
800       loaded_script_ptr script;
801
802       qsort (VEC_address (loaded_script_ptr, scripts),
803              VEC_length (loaded_script_ptr, scripts),
804              sizeof (loaded_script_ptr), sort_scripts_by_name);
805       for (i = 0; VEC_iterate (loaded_script_ptr, scripts, i, script); ++i)
806         print_script (script);
807     }
808
809   do_cleanups (script_chain);
810
811   if (nr_scripts == 0)
812     {
813       if (pattern && *pattern)
814         ui_out_message (uiout, 0, "No auto-load scripts matching %s.\n",
815                         pattern);
816       else
817         ui_out_message (uiout, 0, "No auto-load scripts.\n");
818     }
819 }
820
821 /* Wrapper for "info auto-load gdb-scripts".  */
822
823 static void
824 info_auto_load_gdb_scripts (char *pattern, int from_tty)
825 {
826   auto_load_info_scripts (pattern, from_tty, &script_language_gdb);
827 }
828
829 /* Implement 'info auto-load local-gdbinit'.  */
830
831 static void
832 info_auto_load_local_gdbinit (char *args, int from_tty)
833 {
834   if (auto_load_local_gdbinit_pathname == NULL)
835     printf_filtered (_("Local .gdbinit file was not found.\n"));
836   else if (auto_load_local_gdbinit_loaded)
837     printf_filtered (_("Local .gdbinit file \"%s\" has been loaded.\n"),
838                      auto_load_local_gdbinit_pathname);
839   else
840     printf_filtered (_("Local .gdbinit file \"%s\" has not been loaded.\n"),
841                      auto_load_local_gdbinit_pathname);
842 }
843
844 /* Return non-zero if SCRIPT_NOT_FOUND_WARNING_PRINTED of PSPACE_INFO was unset
845    before calling this function.  Always set SCRIPT_NOT_FOUND_WARNING_PRINTED
846    of PSPACE_INFO.  */
847
848 int
849 script_not_found_warning_print (struct auto_load_pspace_info *pspace_info)
850 {
851   int retval = !pspace_info->script_not_found_warning_printed;
852
853   pspace_info->script_not_found_warning_printed = 1;
854
855   return retval;
856 }
857
858 /* The only valid "set auto-load" argument is off|0|no|disable.  */
859
860 static void
861 set_auto_load_cmd (char *args, int from_tty)
862 {
863   struct cmd_list_element *list;
864   size_t length;
865
866   /* See parse_binary_operation in use by the sub-commands.  */
867
868   length = args ? strlen (args) : 0;
869
870   while (length > 0 && (args[length - 1] == ' ' || args[length - 1] == '\t'))
871     length--;
872
873   if (length == 0 || (strncmp (args, "off", length) != 0
874                       && strncmp (args, "0", length) != 0
875                       && strncmp (args, "no", length) != 0
876                       && strncmp (args, "disable", length) != 0))
877     error (_("Valid is only global 'set auto-load no'; "
878              "otherwise check the auto-load sub-commands."));
879
880   for (list = *auto_load_set_cmdlist_get (); list != NULL; list = list->next)
881     if (list->var_type == var_boolean)
882       {
883         gdb_assert (list->type == set_cmd);
884         do_setshow_command (args, from_tty, list);
885       }
886 }
887
888 /* Initialize "set auto-load " commands prefix and return it.  */
889
890 struct cmd_list_element **
891 auto_load_set_cmdlist_get (void)
892 {
893   static struct cmd_list_element *retval;
894
895   if (retval == NULL)
896     add_prefix_cmd ("auto-load", class_maintenance, set_auto_load_cmd, _("\
897 Auto-loading specific settings.\n\
898 Configure various auto-load-specific variables such as\n\
899 automatic loading of Python scripts."),
900                     &retval, "set auto-load ",
901                     1/*allow-unknown*/, &setlist);
902
903   return &retval;
904 }
905
906 /* Command "show auto-load" displays summary of all the current
907    "show auto-load " settings.  */
908
909 static void
910 show_auto_load_cmd (char *args, int from_tty)
911 {
912   cmd_show_list (*auto_load_show_cmdlist_get (), from_tty, "");
913 }
914
915 /* Initialize "show auto-load " commands prefix and return it.  */
916
917 struct cmd_list_element **
918 auto_load_show_cmdlist_get (void)
919 {
920   static struct cmd_list_element *retval;
921
922   if (retval == NULL)
923     add_prefix_cmd ("auto-load", class_maintenance, show_auto_load_cmd, _("\
924 Show auto-loading specific settings.\n\
925 Show configuration of various auto-load-specific variables such as\n\
926 automatic loading of Python scripts."),
927                     &retval, "show auto-load ",
928                     0/*allow-unknown*/, &showlist);
929
930   return &retval;
931 }
932
933 /* Command "info auto-load" displays whether the various auto-load files have
934    been loaded.  This is reimplementation of cmd_show_list which inserts
935    newlines at proper places.  */
936
937 static void
938 info_auto_load_cmd (char *args, int from_tty)
939 {
940   struct cmd_list_element *list;
941   struct cleanup *infolist_chain;
942   struct ui_out *uiout = current_uiout;
943
944   infolist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "infolist");
945
946   for (list = *auto_load_info_cmdlist_get (); list != NULL; list = list->next)
947     {
948       struct cleanup *option_chain
949         = make_cleanup_ui_out_tuple_begin_end (uiout, "option");
950
951       gdb_assert (!list->prefixlist);
952       gdb_assert (list->type == not_set_cmd);
953
954       ui_out_field_string (uiout, "name", list->name);
955       ui_out_text (uiout, ":  ");
956       cmd_func (list, auto_load_info_scripts_pattern_nl, from_tty);
957
958       /* Close the tuple.  */
959       do_cleanups (option_chain);
960     }
961
962   /* Close the tuple.  */
963   do_cleanups (infolist_chain);
964 }
965
966 /* Initialize "info auto-load " commands prefix and return it.  */
967
968 struct cmd_list_element **
969 auto_load_info_cmdlist_get (void)
970 {
971   static struct cmd_list_element *retval;
972
973   if (retval == NULL)
974     add_prefix_cmd ("auto-load", class_info, info_auto_load_cmd, _("\
975 Print current status of auto-loaded files.\n\
976 Print whether various files like Python scripts or .gdbinit files have been\n\
977 found and/or loaded."),
978                     &retval, "info auto-load ",
979                     0/*allow-unknown*/, &infolist);
980
981   return &retval;
982 }
983
984 void _initialize_auto_load (void);
985
986 void
987 _initialize_auto_load (void)
988 {
989   struct cmd_list_element *cmd;
990
991   auto_load_pspace_data
992     = register_program_space_data_with_cleanup (auto_load_pspace_data_cleanup);
993
994   observer_attach_new_objfile (auto_load_new_objfile);
995
996   add_setshow_boolean_cmd ("gdb-scripts", class_support,
997                            &auto_load_gdb_scripts, _("\
998 Enable or disable auto-loading of canned sequences of commands scripts."), _("\
999 Show whether auto-loading of canned sequences of commands scripts is enabled."),
1000                            _("\
1001 If enabled, canned sequences of commands are loaded when the debugger reads\n\
1002 an executable or shared library.\n\
1003 This options has security implications for untrusted inferiors."),
1004                            NULL, show_auto_load_gdb_scripts,
1005                            auto_load_set_cmdlist_get (),
1006                            auto_load_show_cmdlist_get ());
1007
1008   add_cmd ("gdb-scripts", class_info, info_auto_load_gdb_scripts,
1009            _("Print the list of automatically loaded sequences of commands.\n\
1010 Usage: info auto-load gdb-scripts [REGEXP]"),
1011            auto_load_info_cmdlist_get ());
1012
1013   add_setshow_boolean_cmd ("local-gdbinit", class_support,
1014                            &auto_load_local_gdbinit, _("\
1015 Enable or disable auto-loading of .gdbinit script in current directory."), _("\
1016 Show whether auto-loading .gdbinit script in current directory is enabled."),
1017                            _("\
1018 If enabled, canned sequences of commands are loaded when debugger starts\n\
1019 from .gdbinit file in current directory.  Such files are deprecated,\n\
1020 use a script associated with inferior executable file instead.\n\
1021 This options has security implications for untrusted inferiors."),
1022                            NULL, show_auto_load_local_gdbinit,
1023                            auto_load_set_cmdlist_get (),
1024                            auto_load_show_cmdlist_get ());
1025
1026   add_cmd ("local-gdbinit", class_info, info_auto_load_local_gdbinit,
1027            _("Print whether current directory .gdbinit file has been loaded.\n\
1028 Usage: info auto-load local-gdbinit"),
1029            auto_load_info_cmdlist_get ());
1030
1031   auto_load_safe_path = xstrdup (DEFAULT_AUTO_LOAD_SAFE_PATH);
1032   auto_load_safe_path_vec_update ();
1033   add_setshow_optional_filename_cmd ("safe-path", class_support,
1034                                      &auto_load_safe_path, _("\
1035 Set the list of directories from which it is safe to auto-load files."), _("\
1036 Show the list of directories from which it is safe to auto-load files."), _("\
1037 Various files loaded automatically for the 'set auto-load ...' options must\n\
1038 be located in one of the directories listed by this option.  Warning will be\n\
1039 printed and file will not be used otherwise.\n\
1040 Setting this parameter to an empty list resets it to its default value.\n\
1041 Setting this parameter to '/' (without the quotes) allows any file\n\
1042 for the 'set auto-load ...' options.\n\
1043 This option is ignored for the kinds of files having 'set auto-load ... off'.\n\
1044 This options has security implications for untrusted inferiors."),
1045                                      set_auto_load_safe_path,
1046                                      show_auto_load_safe_path,
1047                                      auto_load_set_cmdlist_get (),
1048                                      auto_load_show_cmdlist_get ());
1049
1050   cmd = add_cmd ("add-auto-load-safe-path", class_support,
1051                  add_auto_load_safe_path,
1052                  _("Add entries to the list of directories from which it is safe "
1053                    "to auto-load files.\n\
1054 See the commands 'set auto-load safe-path' and 'show auto-load safe-path' to\n\
1055 access the current full list setting."),
1056                  &cmdlist);
1057   set_cmd_completer (cmd, filename_completer);
1058
1059   add_setshow_boolean_cmd ("auto-load", class_maintenance,
1060                            &debug_auto_load, _("\
1061 Set auto-load verifications debugging."), _("\
1062 Show auto-load verifications debugging."), _("\
1063 When non-zero, debugging output for files of 'set auto-load ...'\n\
1064 is displayed."),
1065                             NULL, show_debug_auto_load,
1066                             &setdebuglist, &showdebuglist);
1067 }