*** empty log message ***

[deliverable/binutils-gdb.git] / gdb / gnu-nat.c

diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c
index 80ceb9075ad5fb42e0d08370e0aa8e69806f4104..08971cfc8c286874dfc2f09e766110d681030c9a 100644 (file)
--- a/gdb/gnu-nat.c
+++ b/gdb/gnu-nat.c
@@ -1,6 +1,6 @@
 /* Interface GDB to the GNU Hurd.
 /* Interface GDB to the GNU Hurd.

-   Copyright (C) 1992, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2006, 2007
-   Free Software Foundation, Inc.
+   Copyright (C) 1992, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2006, 2007,
+   2008, 2009 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -10,7 +10,7 @@
 
    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
 
    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 2 of the License, or
+   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,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -19,9 +19,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    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, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.

  */
 
 #include <ctype.h>
  */
 
 #include <ctype.h>


@@ -1068,6 +1066,8 @@ inf_validate_procs (struct inf *inf)
        else
          /* THREADS[I] is a thread we don't know about yet!  */
          {
        else
          /* THREADS[I] is a thread we don't know about yet!  */
          {

+           ptid_t ptid;
+

            thread = make_proc (inf, threads[i], next_thread_id++);
            if (last)
              last->next = thread;
            thread = make_proc (inf, threads[i], next_thread_id++);
            if (last)
              last->next = thread;


@@ -1075,7 +1075,20 @@ inf_validate_procs (struct inf *inf)
              inf->threads = thread;
            last = thread;
            proc_debug (thread, "new thread: %d", threads[i]);
              inf->threads = thread;
            last = thread;
            proc_debug (thread, "new thread: %d", threads[i]);

-           add_thread (pid_to_ptid (thread->tid));     /* Tell GDB's generic thread code.  */
+
+           ptid = ptid_build (inf->pid, 0, thread->tid);
+
+           /* Tell GDB's generic thread code.  */
+
+           if (ptid_equal (inferior_ptid, pid_to_ptid (inf->pid)))
+             /* This is the first time we're hearing about thread
+                ids, after a fork-child.  */
+             thread_change_ptid (inferior_ptid, ptid);
+           else if (inf->pending_execs != 0)
+             /* This is a shell thread.  */
+             add_thread_silent (ptid);
+           else
+             add_thread (ptid);

          }
       }
 
          }
       }
 


@@ -1412,7 +1425,7 @@ inf_continue (struct inf *inf)
 
 \f
 /* The inferior used for all gdb target ops.  */
 
 \f
 /* The inferior used for all gdb target ops.  */

-struct inf *current_inferior = 0;
+struct inf *gnu_current_inf = 0;

 
 /* The inferior being waited for by gnu_wait.  Since GDB is decidely not
    multi-threaded, we don't bother to lock this.  */
 
 /* The inferior being waited for by gnu_wait.  Since GDB is decidely not
    multi-threaded, we don't bother to lock this.  */


@@ -1420,7 +1433,7 @@ struct inf *waiting_inf;
 
 /* Wait for something to happen in the inferior, returning what in STATUS. */
 static ptid_t
 
 /* Wait for something to happen in the inferior, returning what in STATUS. */
 static ptid_t

-gnu_wait (ptid_t tid, struct target_waitstatus *status)
+gnu_wait (ptid_t ptid, struct target_waitstatus *status)

 {
   struct msg
     {
 {
   struct msg
     {


@@ -1430,7 +1443,7 @@ gnu_wait (ptid_t tid, struct target_waitstatus *status)
     } msg;
   error_t err;
   struct proc *thread;
     } msg;
   error_t err;
   struct proc *thread;

-  struct inf *inf = current_inferior;
+  struct inf *inf = gnu_current_inf;

 
   extern int exc_server (mach_msg_header_t *, mach_msg_header_t *);
   extern int msg_reply_server (mach_msg_header_t *, mach_msg_header_t *);
 
   extern int exc_server (mach_msg_header_t *, mach_msg_header_t *);
   extern int msg_reply_server (mach_msg_header_t *, mach_msg_header_t *);


@@ -1451,7 +1464,7 @@ gnu_wait (ptid_t tid, struct target_waitstatus *status)
 
   waiting_inf = inf;
 
 
   waiting_inf = inf;
 

-  inf_debug (inf, "waiting for: %d", PIDGET (tid));
+  inf_debug (inf, "waiting for: %s", target_pid_to_str (ptid));

 
 rewait:
   if (proc_wait_pid != inf->pid && !inf->no_wait)
 
 rewait:
   if (proc_wait_pid != inf->pid && !inf->no_wait)


@@ -1587,20 +1600,24 @@ rewait:
 
   thread = inf->wait.thread;
   if (thread)
 
   thread = inf->wait.thread;
   if (thread)

-    tid = pid_to_ptid (thread->tid);
+    ptid = ptid_build (inf->pid, 0, thread->tid);
+  else if (ptid_equal (ptid, minus_one_ptid))
+    thread = inf_tid_to_thread (inf, -1);

   else
   else

-    thread = inf_tid_to_thread (inf, PIDGET (tid));
+    thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));

 
   if (!thread || thread->port == MACH_PORT_NULL)
     {
       /* TID is dead; try and find a new thread.  */
       if (inf_update_procs (inf) && inf->threads)
 
   if (!thread || thread->port == MACH_PORT_NULL)
     {
       /* TID is dead; try and find a new thread.  */
       if (inf_update_procs (inf) && inf->threads)

-       tid = pid_to_ptid (inf->threads->tid); /* The first available thread.  */
+       ptid = ptid_build (inf->pid, 0, inf->threads->tid); /* The first available thread.  */

       else
       else

-       tid = inferior_ptid;    /* let wait_for_inferior handle exit case */
+       ptid = inferior_ptid;   /* let wait_for_inferior handle exit case */

     }
 
     }
 

-  if (thread && PIDGET (tid) >= 0 && status->kind != TARGET_WAITKIND_SPURIOUS
+  if (thread
+      && !ptid_equal (ptid, minus_one_ptid)
+      && status->kind != TARGET_WAITKIND_SPURIOUS

       && inf->pause_sc == 0 && thread->pause_sc == 0)
     /* If something actually happened to THREAD, make sure we
        suspend it.  */
       && inf->pause_sc == 0 && thread->pause_sc == 0)
     /* If something actually happened to THREAD, make sure we
        suspend it.  */


@@ -1609,7 +1626,8 @@ rewait:
       inf_update_suspends (inf);
     }
 
       inf_update_suspends (inf);
     }
 

-  inf_debug (inf, "returning tid = %d, status = %s (%d)", PIDGET (tid),
+  inf_debug (inf, "returning ptid = %s, status = %s (%d)",
+            target_pid_to_str (ptid),

             status->kind == TARGET_WAITKIND_EXITED ? "EXITED"
             : status->kind == TARGET_WAITKIND_STOPPED ? "STOPPED"
             : status->kind == TARGET_WAITKIND_SIGNALLED ? "SIGNALLED"
             status->kind == TARGET_WAITKIND_EXITED ? "EXITED"
             : status->kind == TARGET_WAITKIND_STOPPED ? "STOPPED"
             : status->kind == TARGET_WAITKIND_SIGNALLED ? "SIGNALLED"


@@ -1618,7 +1636,7 @@ rewait:
             : "?",
             status->value.integer);
 
             : "?",
             status->value.integer);
 

-  return tid;
+  return ptid;

 }
 
 \f
 }
 
 \f


@@ -1936,12 +1954,14 @@ port_msgs_queued (mach_port_t port)
    in multiple events returned by wait).
  */
 static void
    in multiple events returned by wait).
  */
 static void

-gnu_resume (ptid_t tid, int step, enum target_signal sig)
+gnu_resume (ptid_t ptid, int step, enum target_signal sig)

 {
   struct proc *step_thread = 0;
 {
   struct proc *step_thread = 0;

-  struct inf *inf = current_inferior;
+  int resume_all;
+  struct inf *inf = gnu_current_inf;

 
 

-  inf_debug (inf, "tid = %d, step = %d, sig = %d", PIDGET (tid), step, sig);
+  inf_debug (inf, "ptid = %s, step = %d, sig = %d",
+            target_pid_to_str (ptid), step, sig);

 
   inf_validate_procinfo (inf);
 
 
   inf_validate_procinfo (inf);
 


@@ -1969,30 +1989,35 @@ gnu_resume (ptid_t tid, int step, enum target_signal sig)
 
   inf_update_procs (inf);
 
 
   inf_update_procs (inf);
 

-  if (PIDGET (tid) < 0)
+  /* A specific PTID means `step only this process id'.  */
+  resume_all = ptid_equal (ptid, minus_one_ptid);
+
+  if (resume_all)

     /* Allow all threads to run, except perhaps single-stepping one.  */
     {
       inf_debug (inf, "running all threads; tid = %d", PIDGET (inferior_ptid));
     /* Allow all threads to run, except perhaps single-stepping one.  */
     {
       inf_debug (inf, "running all threads; tid = %d", PIDGET (inferior_ptid));

-      tid = inferior_ptid;     /* What to step. */
+      ptid = inferior_ptid;    /* What to step. */

       inf_set_threads_resume_sc (inf, 0, 1);
     }
   else
     /* Just allow a single thread to run.  */
     {
       inf_set_threads_resume_sc (inf, 0, 1);
     }
   else
     /* Just allow a single thread to run.  */
     {

-      struct proc *thread = inf_tid_to_thread (inf, PIDGET (tid));
+      struct proc *thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));

       if (!thread)
       if (!thread)

-       error (_("Can't run single thread id %d: no such thread!"), inf->pid);
-      inf_debug (inf, "running one thread: %d/%d", inf->pid, thread->tid);
+       error (_("Can't run single thread id %s: no such thread!"),
+              target_pid_to_str (ptid));
+      inf_debug (inf, "running one thread: %s", target_pid_to_str (ptid));

       inf_set_threads_resume_sc (inf, thread, 0);
     }
 
   if (step)
     {
       inf_set_threads_resume_sc (inf, thread, 0);
     }
 
   if (step)
     {

-      step_thread = inf_tid_to_thread (inf, PIDGET (tid));
+      step_thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));

       if (!step_thread)
       if (!step_thread)

-       warning (_("Can't step thread id %d: no such thread."), PIDGET (tid));
+       warning (_("Can't step thread id %s: no such thread."),
+                target_pid_to_str (ptid));

       else
       else

-       inf_debug (inf, "stepping thread: %d/%d", inf->pid, step_thread->tid);
+       inf_debug (inf, "stepping thread: %s", target_pid_to_str (ptid));

     }
   if (step_thread != inf->step_thread)
     inf_set_step_thread (inf, step_thread);
     }
   if (step_thread != inf->step_thread)
     inf_set_step_thread (inf, step_thread);


@@ -2005,22 +2030,22 @@ gnu_resume (ptid_t tid, int step, enum target_signal sig)
 static void
 gnu_kill_inferior (void)
 {
 static void
 gnu_kill_inferior (void)
 {

-  struct proc *task = current_inferior->task;
+  struct proc *task = gnu_current_inf->task;

   if (task)
     {
       proc_debug (task, "terminating...");
       task_terminate (task->port);
   if (task)
     {
       proc_debug (task, "terminating...");
       task_terminate (task->port);

-      inf_set_pid (current_inferior, -1);
+      inf_set_pid (gnu_current_inf, -1);

     }
   target_mourn_inferior ();
 }
 
 /* Clean up after the inferior dies.  */
 static void
     }
   target_mourn_inferior ();
 }
 
 /* Clean up after the inferior dies.  */
 static void

-gnu_mourn_inferior (void)
+gnu_mourn_inferior (struct target_ops *ops)

 {
 {

-  inf_debug (current_inferior, "rip");
-  inf_detach (current_inferior);
+  inf_debug (gnu_current_inf, "rip");
+  inf_detach (gnu_current_inf);

   unpush_target (&gnu_ops);
   generic_mourn_inferior ();
 }
   unpush_target (&gnu_ops);
   generic_mourn_inferior ();
 }


@@ -2032,9 +2057,9 @@ gnu_mourn_inferior (void)
 static int
 inf_pick_first_thread (void)
 {
 static int
 inf_pick_first_thread (void)
 {

-  if (current_inferior->task && current_inferior->threads)
+  if (gnu_current_inf->task && gnu_current_inf->threads)

     /* The first thread.  */
     /* The first thread.  */

-    return current_inferior->threads->tid;
+    return gnu_current_inf->threads->tid;

   else
     /* What may be the next thread.  */
     return next_thread_id;
   else
     /* What may be the next thread.  */
     return next_thread_id;


@@ -2043,13 +2068,14 @@ inf_pick_first_thread (void)
 static struct inf *
 cur_inf (void)
 {
 static struct inf *
 cur_inf (void)
 {

-  if (!current_inferior)
-    current_inferior = make_inf ();
-  return current_inferior;
+  if (!gnu_current_inf)
+    gnu_current_inf = make_inf ();
+  return gnu_current_inf;

 }
 
 static void
 }
 
 static void

-gnu_create_inferior (char *exec_file, char *allargs, char **env,
+gnu_create_inferior (struct target_ops *ops, 
+                    char *exec_file, char *allargs, char **env,

                     int from_tty)
 {
   struct inf *inf = cur_inf ();
                     int from_tty)
 {
   struct inf *inf = cur_inf ();


@@ -2068,7 +2094,6 @@ gnu_create_inferior (char *exec_file, char *allargs, char **env,
 
     inf_attach (inf, pid);
 
 
     inf_attach (inf, pid);
 

-    attach_flag = 0;

     push_target (&gnu_ops);
 
     inf->pending_execs = 2;
     push_target (&gnu_ops);
 
     inf->pending_execs = 2;


@@ -2078,7 +2103,10 @@ gnu_create_inferior (char *exec_file, char *allargs, char **env,
     /* Now let the child run again, knowing that it will stop immediately
        because of the ptrace. */
     inf_resume (inf);
     /* Now let the child run again, knowing that it will stop immediately
        because of the ptrace. */
     inf_resume (inf);

-    inferior_ptid = pid_to_ptid (inf_pick_first_thread ());
+
+    /* We now have thread info.  */
+    thread_change_ptid (inferior_ptid,
+                       ptid_build (inf->pid, 0, inf_pick_first_thread ()));

 
     startup_inferior (inf->pending_execs);
   }
 
     startup_inferior (inf->pending_execs);
   }


@@ -2112,11 +2140,12 @@ gnu_can_run (void)
 /* Attach to process PID, then initialize for debugging it
    and wait for the trace-trap that results from attaching.  */
 static void
 /* Attach to process PID, then initialize for debugging it
    and wait for the trace-trap that results from attaching.  */
 static void

-gnu_attach (char *args, int from_tty)
+gnu_attach (struct target_ops *ops, char *args, int from_tty)

 {
   int pid;
   char *exec_file;
   struct inf *inf = cur_inf ();
 {
   int pid;
   char *exec_file;
   struct inf *inf = cur_inf ();

+  struct inferior *inferior;

 
   if (!args)
     error_no_arg (_("process-id to attach"));
 
   if (!args)
     error_no_arg (_("process-id to attach"));


@@ -2142,13 +2171,16 @@ gnu_attach (char *args, int from_tty)
   inf_debug (inf, "attaching to pid: %d", pid);
 
   inf_attach (inf, pid);
   inf_debug (inf, "attaching to pid: %d", pid);
 
   inf_attach (inf, pid);

-  inf_update_procs (inf);
-
-  inferior_ptid = pid_to_ptid (inf_pick_first_thread ());

 
 

-  attach_flag = 1;

   push_target (&gnu_ops);
 
   push_target (&gnu_ops);
 

+  inferior = add_inferior (pid);
+  inferior->attach_flag = 1;
+
+  inf_update_procs (inf);
+
+  inferior_ptid = ptid_build (pid, 0, inf_pick_first_thread ());
+

   /* We have to initialize the terminal settings now, since the code
      below might try to restore them.  */
   target_terminal_init ();
   /* We have to initialize the terminal settings now, since the code
      below might try to restore them.  */
   target_terminal_init ();


@@ -2174,22 +2206,27 @@ gnu_attach (char *args, int from_tty)
    previously attached.  It *might* work if the program was
    started via fork.  */
 static void
    previously attached.  It *might* work if the program was
    started via fork.  */
 static void

-gnu_detach (char *args, int from_tty)
+gnu_detach (struct target_ops *ops, char *args, int from_tty)

 {
 {

+  int pid;
+

   if (from_tty)
     {
       char *exec_file = get_exec_file (0);
       if (exec_file)
        printf_unfiltered ("Detaching from program `%s' pid %d\n",
   if (from_tty)
     {
       char *exec_file = get_exec_file (0);
       if (exec_file)
        printf_unfiltered ("Detaching from program `%s' pid %d\n",

-                          exec_file, current_inferior->pid);
+                          exec_file, gnu_current_inf->pid);

       else
       else

-       printf_unfiltered ("Detaching from pid %d\n", current_inferior->pid);
+       printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf->pid);

       gdb_flush (gdb_stdout);
     }
 
       gdb_flush (gdb_stdout);
     }
 

-  inf_detach (current_inferior);
+  pid = gnu_current_inf->pid;
+
+  inf_detach (gnu_current_inf);

 
   inferior_ptid = null_ptid;
 
   inferior_ptid = null_ptid;

+  detach_inferior (pid);

 
   unpush_target (&gnu_ops);    /* Pop out of handling an inferior */
 }
 
   unpush_target (&gnu_ops);    /* Pop out of handling an inferior */
 }


@@ -2197,8 +2234,8 @@ gnu_detach (char *args, int from_tty)
 static void
 gnu_terminal_init_inferior (void)
 {
 static void
 gnu_terminal_init_inferior (void)
 {

-  gdb_assert (current_inferior);
-  terminal_init_inferior_with_pgrp (current_inferior->pid);
+  gdb_assert (gnu_current_inf);
+  terminal_init_inferior_with_pgrp (gnu_current_inf->pid);

 }
 
 /* Get ready to modify the registers array.  On machines which store
 }
 
 /* Get ready to modify the registers array.  On machines which store


@@ -2218,24 +2255,17 @@ gnu_open (char *arg, int from_tty)
 }
 
 static void
 }
 
 static void

-gnu_stop (void)
+gnu_stop (ptid_t ptid)

 {
   error (_("to_stop target function not implemented"));
 }
 
 {
   error (_("to_stop target function not implemented"));
 }
 

-static char *
-gnu_pid_to_exec_file (int pid)
-{
-  error (_("to_pid_to_exec_file target function not implemented"));
-  return NULL;
-}
-
-

 static int
 static int

-gnu_thread_alive (ptid_t tid)
+gnu_thread_alive (ptid_t ptid)

 {
 {

-  inf_update_procs (current_inferior);
-  return !!inf_tid_to_thread (current_inferior, PIDGET (tid));
+  inf_update_procs (gnu_current_inf);
+  return !!inf_tid_to_thread (gnu_current_inf,
+                             ptid_get_tid (ptid));

 }
 
 \f
 }
 
 \f


@@ -2449,16 +2479,16 @@ gnu_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
                 struct mem_attrib *attrib,
                 struct target_ops *target)
 {
                 struct mem_attrib *attrib,
                 struct target_ops *target)
 {

-  task_t task = (current_inferior
-                ? (current_inferior->task
-                   ? current_inferior->task->port : 0)
+  task_t task = (gnu_current_inf
+                ? (gnu_current_inf->task
+                   ? gnu_current_inf->task->port : 0)

                 : 0);
 
   if (task == MACH_PORT_NULL)
     return 0;
   else
     {
                 : 0);
 
   if (task == MACH_PORT_NULL)
     return 0;
   else
     {

-      inf_debug (current_inferior, "%s %p[%d] %s %p",
+      inf_debug (gnu_current_inf, "%s %p[%d] %s %p",

                 write ? "writing" : "reading", (void *) memaddr, len,
                 write ? "<--" : "-->", myaddr);
       if (write)
                 write ? "writing" : "reading", (void *) memaddr, len,
                 write ? "<--" : "-->", myaddr);
       if (write)


@@ -2481,9 +2511,9 @@ gnu_find_memory_regions (int (*func) (CORE_ADDR,
   vm_address_t region_address, last_region_address, last_region_end;
   vm_prot_t last_protection;
 
   vm_address_t region_address, last_region_address, last_region_end;
   vm_prot_t last_protection;
 

-  if (current_inferior == 0 || current_inferior->task == 0)
+  if (gnu_current_inf == 0 || gnu_current_inf->task == 0)

     return 0;
     return 0;

-  task = current_inferior->task->port;
+  task = gnu_current_inf->task->port;

   if (task == MACH_PORT_NULL)
     return 0;
 
   if (task == MACH_PORT_NULL)
     return 0;
 


@@ -2558,16 +2588,16 @@ proc_string (struct proc *proc)
   if (proc_is_task (proc))
     sprintf (tid_str, "process %d", proc->inf->pid);
   else
   if (proc_is_task (proc))
     sprintf (tid_str, "process %d", proc->inf->pid);
   else

-    sprintf (tid_str, "thread %d.%d",
-            proc->inf->pid, pid_to_thread_id (MERGEPID (proc->tid, 0)));
+    sprintf (tid_str, "Thread %d.%d",
+            proc->inf->pid, proc->tid);

   return tid_str;
 }
 
 static char *
 gnu_pid_to_str (ptid_t ptid)
 {
   return tid_str;
 }
 
 static char *
 gnu_pid_to_str (ptid_t ptid)
 {

-  struct inf *inf = current_inferior;
-  int tid = PIDGET (ptid);
+  struct inf *inf = gnu_current_inf;
+  int tid = ptid_get_tid (ptid);

   struct proc *thread = inf_tid_to_thread (inf, tid);
 
   if (thread)
   struct proc *thread = inf_tid_to_thread (inf, tid);
 
   if (thread)


@@ -2594,6 +2624,7 @@ init_gnu_ops (void)
   gnu_ops.to_doc = "GNU Hurd process"; /* to_doc */
   gnu_ops.to_open = gnu_open;          /* to_open */
   gnu_ops.to_attach = gnu_attach;      /* to_attach */
   gnu_ops.to_doc = "GNU Hurd process"; /* to_doc */
   gnu_ops.to_open = gnu_open;          /* to_open */
   gnu_ops.to_attach = gnu_attach;      /* to_attach */

+  gnu_ops.to_attach_no_wait = 1;       /* to_attach_no_wait */

   gnu_ops.to_detach = gnu_detach;      /* to_detach */
   gnu_ops.to_resume = gnu_resume;      /* to_resume */
   gnu_ops.to_wait = gnu_wait;          /* to_wait */
   gnu_ops.to_detach = gnu_detach;      /* to_detach */
   gnu_ops.to_resume = gnu_resume;      /* to_resume */
   gnu_ops.to_wait = gnu_wait;          /* to_wait */


@@ -2617,7 +2648,6 @@ init_gnu_ops (void)
   gnu_ops.to_thread_alive = gnu_thread_alive;  /* to_thread_alive */
   gnu_ops.to_pid_to_str = gnu_pid_to_str;   /* to_pid_to_str */
   gnu_ops.to_stop = gnu_stop;  /* to_stop */
   gnu_ops.to_thread_alive = gnu_thread_alive;  /* to_thread_alive */
   gnu_ops.to_pid_to_str = gnu_pid_to_str;   /* to_pid_to_str */
   gnu_ops.to_stop = gnu_stop;  /* to_stop */

-  gnu_ops.to_pid_to_exec_file = gnu_pid_to_exec_file; /* to_pid_to_exec_file */

   gnu_ops.to_stratum = process_stratum;                /* to_stratum */
   gnu_ops.to_has_all_memory = 1;       /* to_has_all_memory */
   gnu_ops.to_has_memory = 1;           /* to_has_memory */
   gnu_ops.to_stratum = process_stratum;                /* to_stratum */
   gnu_ops.to_has_all_memory = 1;       /* to_has_all_memory */
   gnu_ops.to_has_memory = 1;           /* to_has_memory */


@@ -2707,7 +2737,8 @@ static struct proc *
 cur_thread (void)
 {
   struct inf *inf = cur_inf ();
 cur_thread (void)
 {
   struct inf *inf = cur_inf ();

-  struct proc *thread = inf_tid_to_thread (inf, PIDGET (inferior_ptid));
+  struct proc *thread = inf_tid_to_thread (inf,
+                                          ptid_get_tid (inferior_ptid));

   if (!thread)
     error (_("No current thread."));
   return thread;
   if (!thread)
     error (_("No current thread."));
   return thread;


@@ -2889,7 +2920,7 @@ set_sig_thread_cmd (char *args, int from_tty)
     inf->signal_thread = 0;
   else
     {
     inf->signal_thread = 0;
   else
     {

-      int tid = PIDGET (thread_id_to_pid (atoi (args)));
+      int tid = ptid_get_tid (thread_id_to_pid (atoi (args)));

       if (tid < 0)
        error (_("Thread ID %s not known.  Use the \"info threads\" command to\n"
               "see the IDs of currently known threads."), args);
       if (tid < 0)
        error (_("Thread ID %s not known.  Use the \"info threads\" command to\n"
               "see the IDs of currently known threads."), args);


@@ -3393,7 +3424,7 @@ flush_inferior_icache (CORE_ADDR pc, int amount)
   vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH;
   error_t ret;
 
   vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH;
   error_t ret;
 

-  ret = vm_machine_attribute (current_inferior->task->port,
+  ret = vm_machine_attribute (gnu_current_inf->task->port,

                              pc,
                              amount,
                              MATTR_CACHE,
                              pc,
                              amount,
                              MATTR_CACHE,