Merge GDB 7.5.1

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.
 
    Contributed by QNX Software Systems Ltd.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
@@ skipping 294 matching lines @@
 
   update_thread_private_data_name (new_thread, tn->name_buf);
 
   pti = (struct private_thread_info *) new_thread->private;
   pti->tid = tid;
   pti->state = state;
   pti->flags = flags;
 #endif /* _NTO_VERSION */
 }
 
-void
+static void
 procfs_find_new_threads (struct target_ops *ops)
 {
   procfs_status status;
   pid_t pid;
   ptid_t ptid;
   pthread_t tid;
   struct thread_info *new_thread;
 
   if (ctl_fd == -1)
     return;
@@ skipping 399 matching lines @@
   sigset_t set;
   siginfo_t info;
   procfs_status status;
   static int exit_signo = 0;    /* To track signals that cause termination.  */
 
   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 
   if (ptid_equal (inferior_ptid, null_ptid))
     {
       ourstatus->kind = TARGET_WAITKIND_STOPPED;
-      ourstatus->value.sig = TARGET_SIGNAL_0;
+      ourstatus->value.sig = GDB_SIGNAL_0;
       exit_signo = 0;
       return null_ptid;
     }
 
   sigemptyset (&set);
   sigaddset (&set, SIGUSR1);
 
   devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
   while (!(status.flags & _DEBUG_FLAG_ISTOP))
     {
       ofunc = (void (*)()) signal (SIGINT, nto_interrupt);
       sigwaitinfo (&set, &info);
       signal (SIGINT, ofunc);
       devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
     }
 
   if (status.flags & _DEBUG_FLAG_SSTEP)
     {
       ourstatus->kind = TARGET_WAITKIND_STOPPED;
-      ourstatus->value.sig = TARGET_SIGNAL_TRAP;
+      ourstatus->value.sig = GDB_SIGNAL_TRAP;
     }
   /* Was it a breakpoint?  */
   else if (status.flags & _DEBUG_FLAG_TRACE)
     {
       ourstatus->kind = TARGET_WAITKIND_STOPPED;
-      ourstatus->value.sig = TARGET_SIGNAL_TRAP;
+      ourstatus->value.sig = GDB_SIGNAL_TRAP;
     }
   else if (status.flags & _DEBUG_FLAG_ISTOP)
     {
       switch (status.why)
         {
         case _DEBUG_WHY_SIGNALLED:
           ourstatus->kind = TARGET_WAITKIND_STOPPED;
           ourstatus->value.sig =
-            target_signal_from_host (status.info.si_signo);
+            gdb_signal_from_host (status.info.si_signo);
           exit_signo = 0;
           break;
         case _DEBUG_WHY_FAULTED:
           ourstatus->kind = TARGET_WAITKIND_STOPPED;
           if (status.info.si_signo == SIGTRAP)
             {
               ourstatus->value.sig = 0;
               exit_signo = 0;
             }
           else
             {
               ourstatus->value.sig =
-                target_signal_from_host (status.info.si_signo);
+                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);
             if (exit_signo)
               {
                 /* Abnormal death.  */
                 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
                 ourstatus->value.sig = exit_signo;
               }
             else
               {
                 /* Normal death.  */
                 ourstatus->kind = TARGET_WAITKIND_EXITED;
                 ourstatus->value.integer = WEXITSTATUS (waitval);
               }
             exit_signo = 0;
             break;
           }
 
         case _DEBUG_WHY_REQUESTED:
           /* We are assuming a requested stop is due to a SIGINT.  */
           ourstatus->kind = TARGET_WAITKIND_STOPPED;
-          ourstatus->value.sig = TARGET_SIGNAL_INT;
+          ourstatus->value.sig = GDB_SIGNAL_INT;
           exit_signo = 0;
           break;
         }
     }
 
   return ptid_build (status.pid, 0, status.tid);
 }
 
 /* Read the current values of the inferior's registers, both the
    general register set and floating point registers (if supported)
@@ skipping 122 matching lines @@
 static int
 procfs_remove_hw_breakpoint (struct gdbarch *gdbarch,
                              struct bp_target_info *bp_tgt)
 {
   return procfs_breakpoint (bp_tgt->placed_address,
                             _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
 }
 
 static void
 procfs_resume (struct target_ops *ops,
-               ptid_t ptid, int step, enum target_signal signo)
+               ptid_t ptid, int step, enum gdb_signal signo)
 {
   int signal_to_pass;
   procfs_status status;
   sigset_t *run_fault = (sigset_t *) (void *) &run.fault;
 
   if (ptid_equal (inferior_ptid, null_ptid))
     return;
 
   procfs_set_thread (ptid_equal (ptid, minus_one_ptid) ? inferior_ptid :
                      ptid);
 
   run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
   if (step)
     run.flags |= _DEBUG_RUN_STEP;
 
   sigemptyset (run_fault);
   sigaddset (run_fault, FLTBPT);
   sigaddset (run_fault, FLTTRACE);
   sigaddset (run_fault, FLTILL);
   sigaddset (run_fault, FLTPRIV);
   sigaddset (run_fault, FLTBOUNDS);
   sigaddset (run_fault, FLTIOVF);
   sigaddset (run_fault, FLTIZDIV);
   sigaddset (run_fault, FLTFPE);
   /* Peter V will be changing this at some point.  */
   sigaddset (run_fault, FLTPAGE);
 
   run.flags |= _DEBUG_RUN_ARM;
 
-  signal_to_pass = target_signal_to_host (signo);
+  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 = target_signal_to_host (signo);
+      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,
                           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);
@@ skipping 332 matching lines @@
 
 static void
 procfs_pass_signals (int numsigs, unsigned char *pass_signals)
 {
   int signo;
 
   sigfillset (&run.trace);
 
   for (signo = 1; signo < NSIG; signo++)
     {
-      int target_signo = target_signal_from_host (signo);
+      int target_signo = gdb_signal_from_host (signo);
       if (target_signo < numsigs && pass_signals[target_signo])
         sigdelset (&run.trace, signo);
     }
 }
 
 static struct tidinfo *
 procfs_thread_info (pid_t pid, short tid)
 {
 /* NYI */
   return NULL;
 }
 
-char *
+static char *
 procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[1024];
   int pid, tid, n;
   struct tidinfo *tip;
 
   pid = ptid_get_pid (ptid);
   tid = ptid_get_tid (ptid);
 
   n = snprintf (buf, 1023, "process %d", pid);
@@ skipping 137 matching lines @@
                              struct expression *cond)
 {
   return procfs_hw_watchpoint (addr, len, type);
 }
 
 static int
 procfs_stopped_by_watchpoint (void)
 {
   return 0;
 }