GDB 7.6.50

gdb/nto-procfs.c

 /* Machine independent support for QNX Neutrino /proc (process file system)
    for GDB.  Written by Colin Burgess at QNX Software Systems Limited.
 
-   Copyright (C) 2003, 2006-2012 Free Software Foundation, Inc.
+   Copyright (C) 2003-2013 Free Software Foundation, Inc.
 
    Contributed by QNX Software Systems Ltd.
 
    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.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 
 #include <fcntl.h>
 #include <spawn.h>
 #include <sys/debug.h>
 #include <sys/procfs.h>
 #include <sys/neutrino.h>
 #include <sys/syspage.h>
-#include "gdb_dirent.h"
+#include <dirent.h>
 #include <sys/netmgr.h>
 
 #include "exceptions.h"
-#include "gdb_string.h"
+#include <string.h>
 #include "gdbcore.h"
 #include "inferior.h"
 #include "target.h"
 #include "objfiles.h"
 #include "gdbthread.h"
 #include "nto-tdep.h"
 #include "command.h"
 #include "regcache.h"
 #include "solib.h"
 
@@ skipping 144 matching lines @@
           if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, total_size, 0) != EOK)
             {
               printf_filtered ("Error getting sysinfo: %d (%s)\n", errno,
                                safe_strerror (errno));
               error (_("Devctl failed."));
             }
           else
             {
               if (sysinfo->type !=
                   nto_map_arch_to_cputype (gdbarch_bfd_arch_info
-                                           (target_gdbarch)->arch_name))
+                                           (target_gdbarch ())->arch_name))
                 error (_("Invalid target CPU."));
             }
         }
     }
   do_cleanups (cleanups);
   printf_filtered ("Debugging using %s\n", nto_procfs_path);
 }
 
 static void
 procfs_set_thread (ptid_t ptid)
@@ skipping 443 matching lines @@
     solib_create_inferior_hook (0);
 }
 
 static ptid_t
 do_attach (ptid_t ptid)
 {
   procfs_status status;
   struct sigevent event;
   char path[PATH_MAX];
 
-  snprintf (path, PATH_MAX - 1, "%s/%d/as", nto_procfs_path, PIDGET (ptid));
+  snprintf (path, PATH_MAX - 1, "%s/%d/as", nto_procfs_path,
+            ptid_get_pid (ptid));
   ctl_fd = open (path, O_RDWR);
   if (ctl_fd == -1)
     error (_("Couldn't open proc file %s, error %d (%s)"), path, errno,
            safe_strerror (errno));
   if (devctl (ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK)
     error (_("Couldn't stop process"));
 
   /* Define a sigevent for process stopped notification.  */
   event.sigev_notify = SIGEV_SIGNAL_THREAD;
   event.sigev_signo = SIGUSR1;
   event.sigev_code = 0;
   event.sigev_value.sival_ptr = NULL;
   event.sigev_priority = -1;
   devctl (ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);
 
   if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK
       && status.flags & _DEBUG_FLAG_STOPPED)
-    SignalKill (nto_node (), PIDGET (ptid), 0, SIGCONT, 0, 0);
+    SignalKill (nto_node (), ptid_get_pid (ptid), 0, SIGCONT, 0, 0);
   nto_init_solib_absolute_prefix ();
-  return ptid_build (PIDGET (ptid), 0, status.tid);
+  return ptid_build (ptid_get_pid (ptid), 0, status.tid);
 }
 
 /* Ask the user what to do when an interrupt is received.  */
 static void
 interrupt_query (void)
 {
   target_terminal_ours ();
 
   if (query (_("Interrupted while waiting for the program.\n\
 Give up (and stop debugging it)? ")))
     {
       target_mourn_inferior ();
-      deprecated_throw_reason (RETURN_QUIT);
+      quit ();
     }
 
   target_terminal_inferior ();
 }
 
 /* The user typed ^C twice.  */
 static void
 nto_interrupt_twice (int signo)
 {
   signal (signo, ofunc);
@@ skipping 74 matching lines @@
               ourstatus->value.sig =
                 gdb_signal_from_host (status.info.si_signo);
               exit_signo = ourstatus->value.sig;
             }
           break;
 
         case _DEBUG_WHY_TERMINATED:
           {
             int waitval = 0;
 
-            waitpid (PIDGET (inferior_ptid), &waitval, WNOHANG);
+            waitpid (ptid_get_pid (inferior_ptid), &waitval, WNOHANG);
             if (exit_signo)
               {
                 /* Abnormal death.  */
                 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
                 ourstatus->value.sig = exit_signo;
               }
             else
               {
                 /* Normal death.  */
                 ourstatus->kind = TARGET_WAITKIND_EXITED;
@@ skipping 66 matching lines @@
         nbytes = 0;
     }
   return (nbytes);
 }
 
 /* Take a program previously attached to and detaches it.
    The program resumes execution and will no longer stop
    on signals, etc.  We'd better not have left any breakpoints
    in the program or it'll die when it hits one.  */
 static void
-procfs_detach (struct target_ops *ops, char *args, int from_tty)
+procfs_detach (struct target_ops *ops, const char *args, int from_tty)
 {
   int siggnal = 0;
   int pid;
 
   if (from_tty)
     {
       char *exec_file = get_exec_file (0);
       if (exec_file == 0)
         exec_file = "";
       printf_unfiltered ("Detaching from program: %s %s\n",
                          exec_file, target_pid_to_str (inferior_ptid));
       gdb_flush (gdb_stdout);
     }
   if (args)
     siggnal = atoi (args);
 
   if (siggnal)
-    SignalKill (nto_node (), PIDGET (inferior_ptid), 0, siggnal, 0, 0);
+    SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, siggnal, 0, 0);
 
   close (ctl_fd);
   ctl_fd = -1;
 
   pid = ptid_get_pid (inferior_ptid);
   inferior_ptid = null_ptid;
   detach_inferior (pid);
   init_thread_list ();
   unpush_target (&procfs_ops);  /* Pop out of handling an inferior.  */
 }
@@ skipping 77 matching lines @@
   signal_to_pass = gdb_signal_to_host (signo);
 
   if (signal_to_pass)
     {
       devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
       signal_to_pass = gdb_signal_to_host (signo);
       if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
         {
           if (signal_to_pass != status.info.si_signo)
             {
-              SignalKill (nto_node (), PIDGET (inferior_ptid), 0,
+              SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0,
                           signal_to_pass, 0, 0);
               run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
             }
           else          /* Let it kill the program without telling us.  */
             sigdelset (&run.trace, signal_to_pass);
         }
     }
   else
     run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;
 
   errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0);
   if (errno != EOK)
     {
       perror (_("run error!\n"));
       return;
     }
 }
 
 static void
 procfs_mourn_inferior (struct target_ops *ops)
 {
   if (!ptid_equal (inferior_ptid, null_ptid))
     {
-      SignalKill (nto_node (), PIDGET (inferior_ptid), 0, SIGKILL, 0, 0);
+      SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, SIGKILL, 0, 0);
       close (ctl_fd);
     }
   inferior_ptid = null_ptid;
   init_thread_list ();
   unpush_target (&procfs_ops);
   generic_mourn_inferior ();
 }
 
 /* This function breaks up an argument string into an argument
    vector suitable for passing to execvp().
@@ skipping 474 matching lines @@
                              struct expression *cond)
 {
   return procfs_hw_watchpoint (addr, len, type);
 }
 
 static int
 procfs_stopped_by_watchpoint (void)
 {
   return 0;
 }