Merge GDB 7.5.1

gdb/main.c

 /* Top level stuff for GDB, the GNU debugger.
 
    Copyright (C) 1986-2005, 2007-2012 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
@@ skipping 23 matching lines @@
 #include "gdb_string.h"
 #include "event-loop.h"
 #include "ui-out.h"
 
 #include "interps.h"
 #include "main.h"
 #include "source.h"
 #include "cli/cli-cmds.h"
 #include "python/python.h"
 #include "objfiles.h"
+#include "auto-load.h"
 
 /* The selected interpreter.  This will be used as a set command
    variable, so it should always be malloc'ed - since
    do_setshow_command will free it.  */
 char *interpreter_p;
 
 /* Whether xdb commands will be handled.  */
 int xdb_commands = 0;
 
 /* Whether dbx commands will be handled.  */
@@ skipping 23 matching lines @@
 
 /* Support for the --batch-silent option.  */
 int batch_silent = 0;
 
 /* Support for --return-child-result option.
    Set the default to -1 to return error in the case
    that the program does not run or does not complete.  */
 int return_child_result = 0;
 int return_child_result_value = -1;
 
-/* Whether to enable writing into executable and core files.  */
-extern int write_files;
 
 /* GDB as it has been invoked from the command line (i.e. argv[0]).  */
 static char *gdb_program_name;
 
 static void print_gdb_help (struct ui_file *);
 
-/* These two are used to set the external editor commands when gdb is
-   farming out files to be edited by another program.  */
-
-extern char *external_editor_command;
-
 /* Relocate a file or directory.  PROGNAME is the name by which gdb
    was invoked (i.e., argv[0]).  INITIAL is the default value for the
    file or directory.  FLAG is true if the value is relocatable, false
    otherwise.  Returns a newly allocated string; this may return NULL
    under the same conditions as make_relative_prefix.  */
 
 static char *
 relocate_path (const char *progname, const char *initial, int flag)
 {
   if (flag)
@@ skipping 120 matching lines @@
   interpreter_async = 1;
 
   current_interp_command_loop ();
   /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
      would clean things up (restoring the cleanup chain) to the state
      they were just prior to the call.  Technically, this means that
      the do_cleanups() below is redundant.  Unfortunately, many FUNCs
      are not that well behaved.  do_cleanups should either be replaced
      with a do_cleanups call (to cover the problem) or an assertion
      check to detect bad FUNCs code.  */
-  do_cleanups (ALL_CLEANUPS);
+  do_cleanups (all_cleanups ());
   /* If the command_loop returned, normally (rather than threw an
      error) we try to quit.  If the quit is aborted, catch_errors()
      which called this catch the signal and restart the command
      loop.  */
   quit_command (NULL, instream == stdin);
   return 1;
 }
 
+/* Arguments of --command option and its counterpart.  */
+typedef struct cmdarg {
+  /* Type of this option.  */
+  enum {
+    /* Option type -x.  */
+    CMDARG_FILE,
+
+    /* Option type -ex.  */
+    CMDARG_COMMAND,
+
+    /* Option type -ix.  */
+    CMDARG_INIT_FILE,
+    
+    /* Option type -iex.  */
+    CMDARG_INIT_COMMAND
+  } type;
+
+  /* Value of this option - filename or the GDB command itself.  String memory
+     is not owned by this structure despite it is 'const'.  */
+  char *string;
+} cmdarg_s;
+
+/* Define type VEC (cmdarg_s).  */
+DEF_VEC_O (cmdarg_s);
+
 static int
 captured_main (void *data)
 {
   struct captured_main_args *context = data;
   int argc = context->argc;
   char **argv = context->argv;
   static int quiet = 0;
   static int set_args = 0;
 
   /* Pointers to various arguments from command line.  */
   char *symarg = NULL;
   char *execarg = NULL;
   char *pidarg = NULL;
   char *corearg = NULL;
   char *pid_or_core_arg = NULL;
   char *cdarg = NULL;
   char *ttyarg = NULL;
 
   /* These are static so that we can take their address in an
      initializer.  */
   static int print_help;
   static int print_version;
 
   /* Pointers to all arguments of --command option.  */
-  struct cmdarg {
-    enum {
-      CMDARG_FILE,
-      CMDARG_COMMAND
-    } type;
-    char *string;
-  } *cmdarg;
-  /* Allocated size of cmdarg.  */
-  int cmdsize;
-  /* Number of elements of cmdarg used.  */
-  int ncmd;
+  VEC (cmdarg_s) *cmdarg_vec = NULL;
+  struct cmdarg *cmdarg_p;
 
   /* Indices of all arguments of --directory option.  */
   char **dirarg;
   /* Allocated size.  */
   int dirsize;
   /* Number of elements used.  */
   int ndir;
 
   /* gdb init files.  */
   char *system_gdbinit;
@@ skipping 15 matching lines @@
 
 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
   setlocale (LC_MESSAGES, "");
 #endif
 #if defined (HAVE_SETLOCALE)
   setlocale (LC_CTYPE, "");
 #endif
   bindtextdomain (PACKAGE, LOCALEDIR);
   textdomain (PACKAGE);
 
-  cmdsize = 1;
-  cmdarg = (struct cmdarg *) xmalloc (cmdsize * sizeof (*cmdarg));
-  ncmd = 0;
+  make_cleanup (VEC_cleanup (cmdarg_s), &cmdarg_vec);
   dirsize = 1;
   dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
   ndir = 0;
 
   quit_flag = 0;
   saved_command_line = (char *) xmalloc (saved_command_line_size);
   saved_command_line[0] = '\0';
   instream = stdin;
 
   gdb_stdout = stdio_fileopen (stdout);
@@ skipping 54 matching lines @@
     /* When var field is 0, use flag field to record the equivalent
        short option (or arbitrary numbers starting at 10 for those
        with no equivalent).  */
     enum {
       OPT_SE = 10,
       OPT_CD,
       OPT_ANNOTATE,
       OPT_STATISTICS,
       OPT_TUI,
       OPT_NOWINDOWS,
-      OPT_WINDOWS
+      OPT_WINDOWS,
+      OPT_IX,
+      OPT_IEX
     };
     static struct option long_options[] =
     {
       {"tui", no_argument, 0, OPT_TUI},
       {"xdb", no_argument, &xdb_commands, 1},
       {"dbx", no_argument, &dbx_commands, 1},
       {"readnow", no_argument, &readnow_symbol_files, 1},
       {"r", no_argument, &readnow_symbol_files, 1},
       {"quiet", no_argument, &quiet, 1},
       {"q", no_argument, &quiet, 1},
@@ skipping 19 matching lines @@
       {"e", required_argument, 0, 'e'},
       {"core", required_argument, 0, 'c'},
       {"c", required_argument, 0, 'c'},
       {"pid", required_argument, 0, 'p'},
       {"p", required_argument, 0, 'p'},
       {"command", required_argument, 0, 'x'},
       {"eval-command", required_argument, 0, 'X'},
       {"version", no_argument, &print_version, 1},
       {"x", required_argument, 0, 'x'},
       {"ex", required_argument, 0, 'X'},
+      {"init-command", required_argument, 0, OPT_IX},
+      {"init-eval-command", required_argument, 0, OPT_IEX},
+      {"ix", required_argument, 0, OPT_IX},
+      {"iex", required_argument, 0, OPT_IEX},
 #ifdef GDBTK
       {"tclcommand", required_argument, 0, 'z'},
       {"enable-external-editor", no_argument, 0, 'y'},
       {"editor-command", required_argument, 0, 'w'},
 #endif
       {"ui", required_argument, 0, 'i'},
       {"interpreter", required_argument, 0, 'i'},
       {"i", required_argument, 0, 'i'},
       {"directory", required_argument, 0, 'd'},
       {"d", required_argument, 0, 'd'},
@@ skipping 88 matching lines @@
           case 'e':
             execarg = optarg;
             break;
           case 'c':
             corearg = optarg;
             break;
           case 'p':
             pidarg = optarg;
             break;
           case 'x':
-            cmdarg[ncmd].type = CMDARG_FILE;
-            cmdarg[ncmd++].string = optarg;
-            if (ncmd >= cmdsize)
-              {
-                cmdsize *= 2;
-                cmdarg = xrealloc ((char *) cmdarg,
-                                   cmdsize * sizeof (*cmdarg));
-              }
+            {
+              struct cmdarg cmdarg = { CMDARG_FILE, optarg };
+
+              VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
+            }
             break;
           case 'X':
-            cmdarg[ncmd].type = CMDARG_COMMAND;
-            cmdarg[ncmd++].string = optarg;
-            if (ncmd >= cmdsize)
-              {
-                cmdsize *= 2;
-                cmdarg = xrealloc ((char *) cmdarg,
-                                   cmdsize * sizeof (*cmdarg));
-              }
+            {
+              struct cmdarg cmdarg = { CMDARG_COMMAND, optarg };
+
+              VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
+            }
+            break;
+          case OPT_IX:
+            {
+              struct cmdarg cmdarg = { CMDARG_INIT_FILE, optarg };
+
+              VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
+            }
+            break;
+          case OPT_IEX:
+            {
+              struct cmdarg cmdarg = { CMDARG_INIT_COMMAND, optarg };
+
+              VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
+            }
             break;
           case 'B':
             batch_flag = batch_silent = 1;
             gdb_stdout = ui_file_new();
             break;
           case 'D':
             xfree (gdb_datadir);
             gdb_datadir = xstrdup (optarg);
             break;
 #ifdef GDBTK
           case 'z':
             {
               extern int gdbtk_test (char *);
 
               if (!gdbtk_test (optarg))
                 {
                   fprintf_unfiltered (gdb_stderr,
                                       _("%s: unable to load "
                                         "tclcommand file \"%s\""),
                                       argv[0], optarg);
                   exit (1);
                 }
               break;
             }
           case 'y':
             /* Backwards compatibility only.  */
             break;
           case 'w':
             {
+              /* Set the external editor commands when gdb is farming out files
+                 to be edited by another program.  */
+              extern char *external_editor_command;
+
               external_editor_command = xstrdup (optarg);
               break;
             }
 #endif /* GDBTK */
           case 'i':
             xfree (interpreter_p);
             interpreter_p = xstrdup (optarg);
             break;
           case 'd':
             dirarg[ndir++] = optarg;
@@ skipping 214 matching lines @@
     catch_command_errors (source_script, system_gdbinit, 0, RETURN_MASK_ALL);
 
   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
      *before* all the command line arguments are processed; it sets
      global parameters, which are independent of what file you are
      debugging or what directory you are in.  */
 
   if (home_gdbinit && !inhibit_gdbinit)
     catch_command_errors (source_script, home_gdbinit, 0, RETURN_MASK_ALL);
 
+  /* Process '-ix' and '-iex' options early.  */
+  for (i = 0; VEC_iterate (cmdarg_s, cmdarg_vec, i, cmdarg_p); i++)
+    switch (cmdarg_p->type)
+    {
+      case CMDARG_INIT_FILE:
+        catch_command_errors (source_script, cmdarg_p->string,
+                              !batch_flag, RETURN_MASK_ALL);
+        break;
+      case CMDARG_INIT_COMMAND:
+        catch_command_errors (execute_command, cmdarg_p->string,
+                              !batch_flag, RETURN_MASK_ALL);
+        break;
+    }
+
   /* Now perform all the actions indicated by the arguments.  */
   if (cdarg != NULL)
     {
       catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
     }
 
   for (i = 0; i < ndir; i++)
     catch_command_errors (directory_switch, dirarg[i], 0, RETURN_MASK_ALL);
   xfree (dirarg);
 
   /* Skip auto-loading section-specified scripts until we've sourced
      local_gdbinit (which is often used to augment the source search
      path).  */
-  save_auto_load = gdbpy_global_auto_load;
-  gdbpy_global_auto_load = 0;
+  save_auto_load = global_auto_load;
+  global_auto_load = 0;
 
   if (execarg != NULL
       && symarg != NULL
       && strcmp (execarg, symarg) == 0)
     {
       /* The exec file and the symbol-file are the same.  If we can't
          open it, better only print one error message.
          catch_command_errors returns non-zero on success!  */
       if (catch_command_errors (exec_file_attach, execarg,
                                 !batch_flag, RETURN_MASK_ALL))
@@ skipping 41 matching lines @@
   if (ttyarg != NULL)
     set_inferior_io_terminal (ttyarg);
 
   /* Error messages should no longer be distinguished with extra output.  */
   error_pre_print = NULL;
   quit_pre_print = NULL;
   warning_pre_print = _("warning: ");
 
   /* Read the .gdbinit file in the current directory, *if* it isn't
      the same as the $HOME/.gdbinit file (it should exist, also).  */
-  if (local_gdbinit && !inhibit_gdbinit)
-    catch_command_errors (source_script, local_gdbinit, 0, RETURN_MASK_ALL);
+  if (local_gdbinit)
+    {
+      auto_load_local_gdbinit_pathname = gdb_realpath (local_gdbinit);
+
+      if (!inhibit_gdbinit && auto_load_local_gdbinit
+          && file_is_auto_load_safe (local_gdbinit,
+                                     _("auto-load: Loading .gdbinit "
+                                       "file \"%s\".\n"),
+                                     local_gdbinit))
+        {
+          auto_load_local_gdbinit_loaded = 1;
+
+          catch_command_errors (source_script, local_gdbinit, 0,
+                                RETURN_MASK_ALL);
+        }
+    }
 
   /* Now that all .gdbinit's have been read and all -d options have been
      processed, we can read any scripts mentioned in SYMARG.
      We wait until now because it is common to add to the source search
      path in local_gdbinit.  */
-  gdbpy_global_auto_load = save_auto_load;
+  global_auto_load = save_auto_load;
   ALL_OBJFILES (objfile)
     load_auto_scripts_for_objfile (objfile);
 
-  for (i = 0; i < ncmd; i++)
+  /* Process '-x' and '-ex' options.  */
+  for (i = 0; VEC_iterate (cmdarg_s, cmdarg_vec, i, cmdarg_p); i++)
+    switch (cmdarg_p->type)
     {
-      if (cmdarg[i].type == CMDARG_FILE)
-        catch_command_errors (source_script, cmdarg[i].string,
+      case CMDARG_FILE:
+        catch_command_errors (source_script, cmdarg_p->string,
                               !batch_flag, RETURN_MASK_ALL);
-      else  /* cmdarg[i].type == CMDARG_COMMAND */
-        catch_command_errors (execute_command, cmdarg[i].string,
+        break;
+      case CMDARG_COMMAND:
+        catch_command_errors (execute_command, cmdarg_p->string,
                               !batch_flag, RETURN_MASK_ALL);
+        break;
     }
-  xfree (cmdarg);
 
   /* Read in the old history after all the command files have been
      read.  */
   init_history ();
 
   if (batch_flag)
     {
       /* We have hit the end of the batch file.  */
       quit_force (NULL, 0);
     }
@@ skipping 50 matching lines @@
   --batch            Exit after processing options.\n\
   --batch-silent     As for --batch, but suppress all gdb stdout output.\n\
   --return-child-result\n\
                      GDB exit code will be the child's exit code.\n\
   --cd=DIR           Change current directory to DIR.\n\
   --command=FILE, -x Execute GDB commands from FILE.\n\
   --eval-command=COMMAND, -ex\n\
                      Execute a single GDB command.\n\
                      May be used multiple times and in conjunction\n\
                      with --command.\n\
+  --init-command=FILE, -ix Like -x but execute it before loading inferior.\n\
+  --init-eval-command=COMMAND, -iex Like -ex but before loading inferior.\n\
   --core=COREFILE    Analyze the core dump COREFILE.\n\
   --pid=PID          Attach to running process PID.\n\
 "), stream);
   fputs_unfiltered (_("\
   --dbx              DBX compatibility mode.\n\
   --directory=DIR    Search for source files in DIR.\n\
   --epoch            Output information used by epoch emacs-GDB interface.\n\
   --exec=EXECFILE    Use EXECFILE as the executable.\n\
   --fullname         Output information used by emacs-GDB interface.\n\
   --help             Print this message.\n\
@@ skipping 33 matching lines @@
   if (system_gdbinit)
     fprintf_unfiltered (stream, _("\
    * system-wide init file: %s\n\
 "), system_gdbinit);
   if (home_gdbinit)
     fprintf_unfiltered (stream, _("\
    * user-specific init file: %s\n\
 "), home_gdbinit);
   if (local_gdbinit)
     fprintf_unfiltered (stream, _("\
-   * local init file: ./%s\n\
+   * local init file (see also 'set auto-load local-gdbinit'): ./%s\n\
 "), local_gdbinit);
   fputs_unfiltered (_("\n\
 For more information, type \"help\" from within GDB, or consult the\n\
 GDB manual (available as on-line info or a printed manual).\n\
 "), stream);
   if (REPORT_BUGS_TO[0] && stream == gdb_stdout)
     fprintf_unfiltered (stream, _("\
 Report bugs to \"%s\".\n\
 "), REPORT_BUGS_TO);
 }