Merge GDB 7.5.1

gdb/fork-child.c

 /* Fork a Unix child process, and set up to debug it, for GDB.
 
    Copyright (C) 1990-1996, 1998-2001, 2004-2012 Free Software
    Foundation, Inc.
 
    Contributed by Cygnus Support.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
@@ skipping 254 matching lines @@
          shell, "-c" says to interpret the next arg as a shell command
          to execute, and this command is "exec <target-program>
          <args>".  */
       argv = (char **) alloca (4 * sizeof (char *));
       argv[0] = shell_file;
       argv[1] = "-c";
       argv[2] = shell_command;
       argv[3] = (char *) 0;
     }
 
-  /* On some systems an exec will fail if the executable is open.  */
-  close_exec_file ();
-
   /* Retain a copy of our environment variables, since the child will
      replace the value of environ and if we're vforked, we have to
      restore it.  */
   save_our_env = environ;
 
   /* Tell the terminal handling subsystem what tty we plan to run on;
      it will just record the information for later.  */
   new_tty_prefork (inferior_io_terminal);
 
   /* It is generally good practice to flush any possible pending stdio
@@ skipping 139 matching lines @@
 
   /* The process was started by the fork that created it, but it will
      have stopped one instruction after execing the shell.  Here we
      must get it up to actual execution of the real program.  */
 
   if (exec_wrapper)
     pending_execs++;
 
   while (1)
     {
-      enum target_signal resume_signal = TARGET_SIGNAL_0;
+      enum gdb_signal resume_signal = GDB_SIGNAL_0;
       ptid_t event_ptid;
 
       struct target_waitstatus ws;
       memset (&ws, 0, sizeof (ws));
       event_ptid = target_wait (resume_ptid, &ws, 0);
 
       if (ws.kind == TARGET_WAITKIND_IGNORE)
         /* The inferior didn't really stop, keep waiting.  */
         continue;
 
       switch (ws.kind)
         {
           case TARGET_WAITKIND_SPURIOUS:
           case TARGET_WAITKIND_LOADED:
           case TARGET_WAITKIND_FORKED:
           case TARGET_WAITKIND_VFORKED:
           case TARGET_WAITKIND_SYSCALL_ENTRY:
           case TARGET_WAITKIND_SYSCALL_RETURN:
             /* Ignore gracefully during startup of the inferior.  */
             switch_to_thread (event_ptid);
             break;
 
           case TARGET_WAITKIND_SIGNALLED:
             target_terminal_ours ();
             target_mourn_inferior ();
             error (_("During startup program terminated with signal %s, %s."),
-                   target_signal_to_name (ws.value.sig),
-                   target_signal_to_string (ws.value.sig));
+                   gdb_signal_to_name (ws.value.sig),
+                   gdb_signal_to_string (ws.value.sig));
             return;
 
           case TARGET_WAITKIND_EXITED:
             target_terminal_ours ();
             target_mourn_inferior ();
             if (ws.value.integer)
               error (_("During startup program exited with code %d."),
                      ws.value.integer);
             else
               error (_("During startup program exited normally."));
             return;
 
           case TARGET_WAITKIND_EXECD:
             /* Handle EXEC signals as if they were SIGTRAP signals.  */
             xfree (ws.value.execd_pathname);
-            resume_signal = TARGET_SIGNAL_TRAP;
+            resume_signal = GDB_SIGNAL_TRAP;
             switch_to_thread (event_ptid);
             break;
 
           case TARGET_WAITKIND_STOPPED:
             resume_signal = ws.value.sig;
             switch_to_thread (event_ptid);
             break;
         }
 
-      if (resume_signal != TARGET_SIGNAL_TRAP)
+      if (resume_signal != GDB_SIGNAL_TRAP)
         {
           /* Let shell child handle its own signals in its own way.  */
           target_resume (resume_ptid, 0, resume_signal);
         }
       else
         {
           /* We handle SIGTRAP, however; it means child did an exec.  */
           if (!terminal_initted)
             {
               /* Now that the child has exec'd we know it has already
                  set its process group.  On POSIX systems, tcsetpgrp
                  will fail with EPERM if we try it before the child's
                  setpgid.  */
 
               /* Set up the "saved terminal modes" of the inferior
                  based on what modes we are starting it with.  */
               target_terminal_init ();
 
               /* Install inferior's terminal modes.  */
               target_terminal_inferior ();
 
               terminal_initted = 1;
             }
 
           if (--pending_execs == 0)
             break;
 
           /* Just make it go on.  */
-          target_resume (resume_ptid, 0, TARGET_SIGNAL_0);
+          target_resume (resume_ptid, 0, GDB_SIGNAL_0);
         }
     }
 
   /* Mark all threads non-executing.  */
   set_executing (resume_ptid, 0);
 }
 
 /* Implement the "unset exec-wrapper" command.  */
 
 static void
@@ skipping 14 matching lines @@
 The wrapper prepares the system and environment for the new program."),
                             _("\
 Show the wrapper for running programs."), NULL,
                             NULL, NULL,
                             &setlist, &showlist);
 
   add_cmd ("exec-wrapper", class_run, unset_exec_wrapper_command,
            _("Disable use of an execution wrapper."),
            &unsetlist);
 }