Merge GDB 7.5.1

gdb/target.c

 /* Select target systems and architectures at runtime for GDB.
 
    Copyright (C) 1990-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
    it under the terms of the GNU General Public License as published by
@@ skipping 11 matching lines @@
 #include "defs.h"
 #include <errno.h>
 #include "gdb_string.h"
 #include "target.h"
 #include "gdbcmd.h"
 #include "symtab.h"
 #include "inferior.h"
 #include "bfd.h"
 #include "symfile.h"
 #include "objfiles.h"
-#include "gdb_wait.h"
 #include "dcache.h"
 #include <signal.h>
 #include "regcache.h"
 #include "gdb_assert.h"
 #include "gdbcore.h"
 #include "exceptions.h"
 #include "target-descriptions.h"
 #include "gdbthread.h"
 #include "solib.h"
 #include "exec.h"
 #include "inline-frame.h"
 #include "tracepoint.h"
+#include "gdb/fileio.h"
+#include "agent.h"
 
 static void target_info (char *, int);
 
 static void default_terminal_info (char *, int);
 
 static int default_watchpoint_addr_within_range (struct target_ops *,
                                                  CORE_ADDR, CORE_ADDR, int);
 
 static int default_region_ok_for_hw_watchpoint (CORE_ADDR, int);
 
@@ skipping 575 matching lines @@
       INHERIT (to_insert_vfork_catchpoint, t);
       INHERIT (to_remove_vfork_catchpoint, t);
       /* Do not inherit to_follow_fork.  */
       INHERIT (to_insert_exec_catchpoint, t);
       INHERIT (to_remove_exec_catchpoint, t);
       INHERIT (to_set_syscall_catchpoint, t);
       INHERIT (to_has_exited, t);
       /* Do not inherit to_mourn_inferior.  */
       INHERIT (to_can_run, t);
       /* Do not inherit to_pass_signals.  */
+      /* Do not inherit to_program_signals.  */
       /* Do not inherit to_thread_alive.  */
       /* Do not inherit to_find_new_threads.  */
       /* Do not inherit to_pid_to_str.  */
       INHERIT (to_extra_thread_info, t);
       INHERIT (to_thread_name, t);
       INHERIT (to_stop, t);
       /* Do not inherit to_xfer_partial.  */
       INHERIT (to_rcmd, t);
       INHERIT (to_pid_to_exec_file, t);
       INHERIT (to_log_command, t);
@@ skipping 40 matching lines @@
       INHERIT (to_get_raw_trace_data, t);
       INHERIT (to_get_min_fast_tracepoint_insn_len, t);
       INHERIT (to_set_disconnected_tracing, t);
       INHERIT (to_set_circular_trace_buffer, t);
       INHERIT (to_set_trace_notes, t);
       INHERIT (to_get_tib_address, t);
       INHERIT (to_set_permissions, t);
       INHERIT (to_static_tracepoint_marker_at, t);
       INHERIT (to_static_tracepoint_markers_by_strid, t);
       INHERIT (to_traceframe_info, t);
+      INHERIT (to_use_agent, t);
+      INHERIT (to_can_use_agent, t);
       INHERIT (to_magic, t);
+      INHERIT (to_supports_evaluation_of_breakpoint_conditions, t);
+      INHERIT (to_can_run_breakpoint_commands, t);
       /* Do not inherit to_memory_map.  */
       /* Do not inherit to_flash_erase.  */
       /* Do not inherit to_flash_done.  */
     }
 #undef INHERIT
 
   /* Clean up a target struct so it no longer has any zero pointers in
      it.  Some entries are defaulted to a method that print an error,
      others are hard-wired to a standard recursive default.  */
 
@@ skipping 206 matching lines @@
             target_ignore);
   de_fault (to_static_tracepoint_marker_at,
             (int (*) (CORE_ADDR, struct static_tracepoint_marker *))
             return_zero);
   de_fault (to_static_tracepoint_markers_by_strid,
             (VEC(static_tracepoint_marker_p) * (*) (const char *))
             tcomplain);
   de_fault (to_traceframe_info,
             (struct traceframe_info * (*) (void))
             tcomplain);
+  de_fault (to_supports_evaluation_of_breakpoint_conditions,
+            (int (*) (void))
+            return_zero);
+  de_fault (to_can_run_breakpoint_commands,
+            (int (*) (void))
+            return_zero);
+  de_fault (to_use_agent,
+            (int (*) (int))
+            tcomplain);
+  de_fault (to_can_use_agent,
+            (int (*) (void))
+            return_zero);
   de_fault (to_execution_direction, default_execution_direction);
 
 #undef de_fault
 
   /* Finally, position the target-stack beneath the squashed
      "current_target".  That way code looking for a non-inherited
      target method can quickly and simply find it.  */
   current_target.beneath = target_stack;
 
   if (targetdebug)
@@ skipping 66 matching lines @@
 
   /* Look for the specified target.  Note that we assume that a target
      can only occur once in the target stack.  */
 
   for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
     {
       if ((*cur) == t)
         break;
     }
 
+  /* If we don't find target_ops, quit.  Only open targets should be
+     closed.  */
   if ((*cur) == NULL)
-    return 0;                   /* Didn't find target_ops, quit now.  */
-
-  /* NOTE: cagney/2003-12-06: In '94 the close call was made
-     unconditional by moving it to before the above check that the
-     target was in the target stack (something about "Change the way
-     pushing and popping of targets work to support target overlays
-     and inheritance").  This doesn't make much sense - only open
-     targets should be closed.  */
-  target_close (t, 0);
+    return 0;                   
 
   /* Unchain the target.  */
   tmp = (*cur);
   (*cur) = (*cur)->beneath;
   tmp->beneath = NULL;
 
   update_current_target ();
 
+  /* Finally close the target.  Note we do this after unchaining, so
+     any target method calls from within the target_close
+     implementation don't end up in T anymore.  */
+  target_close (t, 0);
+
   return 1;
 }
 
 void
 pop_target (void)
 {
   target_close (target_stack, 0);       /* Let it clean up.  */
   if (unpush_target (target_stack) == 1)
     return;
 
@@ skipping 695 matching lines @@
    if any error occurs.
 
    If an error occurs, no guarantee is made about the contents of the data at
    MYADDR.  In particular, the caller should not depend upon partial reads
    filling the buffer with good data.  There is no way for the caller to know
    how much good data might have been transfered anyway.  Callers that can
    deal with partial reads should call target_read (which will retry until
    it makes no progress, and then return how much was transferred).  */
 
 int
-target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
+target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
 {
   /* Dispatch to the topmost target, not the flattened current_target.
      Memory accesses check target->to_has_(all_)memory, and the
      flattened target doesn't inherit those.  */
   if (target_read (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
                    myaddr, memaddr, len) == len)
     return 0;
   else
     return EIO;
 }
 
 /* Like target_read_memory, but specify explicitly that this is a read from
    the target's stack.  This may trigger different cache behavior.  */
 
 int
-target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
+target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
 {
   /* Dispatch to the topmost target, not the flattened current_target.
      Memory accesses check target->to_has_(all_)memory, and the
      flattened target doesn't inherit those.  */
 
   if (target_read (current_target.beneath, TARGET_OBJECT_STACK_MEMORY, NULL,
                    myaddr, memaddr, len) == len)
     return 0;
   else
     return EIO;
 }
 
 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
    Returns either 0 for success or an errno value if any error occurs.
    If an error occurs, no guarantee is made about how much data got written.
    Callers that can deal with partial writes should call target_write.  */
 
 int
-target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
+target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
 {
   /* Dispatch to the topmost target, not the flattened current_target.
      Memory accesses check target->to_has_(all_)memory, and the
      flattened target doesn't inherit those.  */
   if (target_write (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
                     myaddr, memaddr, len) == len)
     return 0;
   else
     return EIO;
 }
 
 /* Write LEN bytes from MYADDR to target raw memory at address
    MEMADDR.  Returns either 0 for success or an errno value if any
    error occurs.  If an error occurs, no guarantee is made about how
    much data got written.  Callers that can deal with partial writes
    should call target_write.  */
 
 int
-target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
+target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
 {
   /* Dispatch to the topmost target, not the flattened current_target.
      Memory accesses check target->to_has_(all_)memory, and the
      flattened target doesn't inherit those.  */
   if (target_write (current_target.beneath, TARGET_OBJECT_RAW_MEMORY, NULL,
                     myaddr, memaddr, len) == len)
     return 0;
   else
     return EIO;
 }
@@ skipping 527 matching lines @@
    returned as a string, allocated using xmalloc.  If an error occurs
    or the transfer is unsupported, NULL is returned.  Empty objects
    are returned as allocated but empty strings.  A warning is issued
    if the result contains any embedded NUL bytes.  */
 
 char *
 target_read_stralloc (struct target_ops *ops, enum target_object object,
                       const char *annex)
 {
   gdb_byte *buffer;
-  LONGEST transferred;
+  LONGEST i, transferred;
 
   transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
 
   if (transferred < 0)
     return NULL;
 
   if (transferred == 0)
     return xstrdup ("");
 
   buffer[transferred] = 0;
-  if (strlen (buffer) < transferred)
-    warning (_("target object %d, annex %s, "
-               "contained unexpected null characters"),
-             (int) object, annex ? annex : "(none)");
+
+  /* Check for embedded NUL bytes; but allow trailing NULs.  */
+  for (i = strlen (buffer); i < transferred; i++)
+    if (buffer[i] != 0)
+      {
+        warning (_("target object %d, annex %s, "
+                   "contained unexpected null characters"),
+                 (int) object, annex ? annex : "(none)");
+        break;
+      }
 
   return (char *) buffer;
 }
 
 /* Memory transfer methods.  */
 
 void
 get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
                    LONGEST len)
 {
@@ skipping 102 matching lines @@
      across inferiors.  If code is shared between processes, so are
      memory regions and features.  */
   if (!gdbarch_has_global_solist (target_gdbarch))
     {
       no_shared_libraries (NULL, from_tty);
 
       invalidate_target_mem_regions ();
 
       target_clear_description ();
     }
+
+  agent_capability_invalidate ();
 }
 
 /* Callback for iterate_over_inferiors.  Gets rid of the given
    inferior.  */
 
 static int
 dispose_inferior (struct inferior *inf, void *args)
 {
   struct thread_info *thread;
 
@@ skipping 147 matching lines @@
   for (t = current_target.beneath; t != NULL; t = t->beneath)
     {
       if (t->to_thread_name != NULL)
         return (*t->to_thread_name) (info);
     }
 
   return NULL;
 }
 
 void
-target_resume (ptid_t ptid, int step, enum target_signal signal)
+target_resume (ptid_t ptid, int step, enum gdb_signal signal)
 {
   struct target_ops *t;
 
   target_dcache_invalidate ();
 
   for (t = current_target.beneath; t != NULL; t = t->beneath)
     {
       if (t->to_resume != NULL)
         {
           t->to_resume (t, ptid, step, signal);
           if (targetdebug)
             fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n",
                                 PIDGET (ptid),
                                 step ? "step" : "continue",
-                                target_signal_to_name (signal));
+                                gdb_signal_to_name (signal));
 
           registers_changed_ptid (ptid);
           set_executing (ptid, 1);
           set_running (ptid, 1);
           clear_inline_frame_state (ptid);
           return;
         }
     }
 
   noprocess ();
@@ skipping 11 matching lines @@
           if (targetdebug)
             {
               int i;
 
               fprintf_unfiltered (gdb_stdlog, "target_pass_signals (%d, {",
                                   numsigs);
 
               for (i = 0; i < numsigs; i++)
                 if (pass_signals[i])
                   fprintf_unfiltered (gdb_stdlog, " %s",
-                                      target_signal_to_name (i));
+                                      gdb_signal_to_name (i));
 
               fprintf_unfiltered (gdb_stdlog, " })\n");
             }
 
           (*t->to_pass_signals) (numsigs, pass_signals);
           return;
         }
     }
 }
 
+void
+target_program_signals (int numsigs, unsigned char *program_signals)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    {
+      if (t->to_program_signals != NULL)
+        {
+          if (targetdebug)
+            {
+              int i;
+
+              fprintf_unfiltered (gdb_stdlog, "target_program_signals (%d, {",
+                                  numsigs);
+
+              for (i = 0; i < numsigs; i++)
+                if (program_signals[i])
+                  fprintf_unfiltered (gdb_stdlog, " %s",
+                                      gdb_signal_to_name (i));
+
+              fprintf_unfiltered (gdb_stdlog, " })\n");
+            }
+
+          (*t->to_program_signals) (numsigs, program_signals);
+          return;
+        }
+    }
+}
+
 /* Look through the list of possible targets for a target that can
    follow forks.  */
 
 int
 target_follow_fork (int follow_child)
 {
   struct target_ops *t;
 
   for (t = current_target.beneath; t != NULL; t = t->beneath)
     {
@@ skipping 354 matching lines @@
 {
   struct target_ops *t;
 
   for (t = &current_target; t != NULL; t = t->beneath)
     if (t->to_supports_non_stop)
       return t->to_supports_non_stop ();
 
   return 0;
 }
 
+/* Implement the "info proc" command.  */
+
+void
+target_info_proc (char *args, enum info_proc_what what)
+{
+  struct target_ops *t;
+
+  /* If we're already connected to something that can get us OS
+     related data, use it.  Otherwise, try using the native
+     target.  */
+  if (current_target.to_stratum >= process_stratum)
+    t = current_target.beneath;
+  else
+    t = find_default_run_target (NULL);
+
+  for (; t != NULL; t = t->beneath)
+    {
+      if (t->to_info_proc != NULL)
+        {
+          t->to_info_proc (t, args, what);
+
+          if (targetdebug)
+            fprintf_unfiltered (gdb_stdlog,
+                                "target_info_proc (\"%s\", %d)\n", args, what);
+
+          return;
+        }
+    }
+
+  error (_("Not supported on this target."));
+}
+
 static int
 find_default_supports_disable_randomization (void)
 {
   struct target_ops *t;
 
   t = find_default_run_target (NULL);
   if (t && t->to_supports_disable_randomization)
     return (t->to_supports_disable_randomization) ();
   return 0;
 }
@@ skipping 59 matching lines @@
 
   if (inf == NULL || inf->aspace == NULL)
     internal_error (__FILE__, __LINE__,
                     _("Can't determine the current "
                       "address space of thread %s\n"),
                     target_pid_to_str (ptid));
 
   return inf->aspace;
 }
 
+
+/* Target file operations.  */
+
+static struct target_ops *
+default_fileio_target (void)
+{
+  /* If we're already connected to something that can perform
+     file I/O, use it. Otherwise, try using the native target.  */
+  if (current_target.to_stratum >= process_stratum)
+    return current_target.beneath;
+  else
+    return find_default_run_target ("file I/O");
+}
+
+/* Open FILENAME on the target, using FLAGS and MODE.  Return a
+   target file descriptor, or -1 if an error occurs (and set
+   *TARGET_ERRNO).  */
+int
+target_fileio_open (const char *filename, int flags, int mode,
+                    int *target_errno)
+{
+  struct target_ops *t;
+
+  for (t = default_fileio_target (); t != NULL; t = t->beneath)
+    {
+      if (t->to_fileio_open != NULL)
+        {
+          int fd = t->to_fileio_open (filename, flags, mode, target_errno);
+
+          if (targetdebug)
+            fprintf_unfiltered (gdb_stdlog,
+                                "target_fileio_open (%s,0x%x,0%o) = %d (%d)\n",
+                                filename, flags, mode,
+                                fd, fd != -1 ? 0 : *target_errno);
+          return fd;
+        }
+    }
+
+  *target_errno = FILEIO_ENOSYS;
+  return -1;
+}
+
+/* Write up to LEN bytes from WRITE_BUF to FD on the target.
+   Return the number of bytes written, or -1 if an error occurs
+   (and set *TARGET_ERRNO).  */
+int
+target_fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
+                      ULONGEST offset, int *target_errno)
+{
+  struct target_ops *t;
+
+  for (t = default_fileio_target (); t != NULL; t = t->beneath)
+    {
+      if (t->to_fileio_pwrite != NULL)
+        {
+          int ret = t->to_fileio_pwrite (fd, write_buf, len, offset,
+                                         target_errno);
+
+          if (targetdebug)
+            fprintf_unfiltered (gdb_stdlog,
+                                "target_fileio_pwrite (%d,...,%d,%s) "
+                                "= %d (%d)\n",
+                                fd, len, pulongest (offset),
+                                ret, ret != -1 ? 0 : *target_errno);
+          return ret;
+        }
+    }
+
+  *target_errno = FILEIO_ENOSYS;
+  return -1;
+}
+
+/* Read up to LEN bytes FD on the target into READ_BUF.
+   Return the number of bytes read, or -1 if an error occurs
+   (and set *TARGET_ERRNO).  */
+int
+target_fileio_pread (int fd, gdb_byte *read_buf, int len,
+                     ULONGEST offset, int *target_errno)
+{
+  struct target_ops *t;
+
+  for (t = default_fileio_target (); t != NULL; t = t->beneath)
+    {
+      if (t->to_fileio_pread != NULL)
+        {
+          int ret = t->to_fileio_pread (fd, read_buf, len, offset,
+                                        target_errno);
+
+          if (targetdebug)
+            fprintf_unfiltered (gdb_stdlog,
+                                "target_fileio_pread (%d,...,%d,%s) "
+                                "= %d (%d)\n",
+                                fd, len, pulongest (offset),
+                                ret, ret != -1 ? 0 : *target_errno);
+          return ret;
+        }
+    }
+
+  *target_errno = FILEIO_ENOSYS;
+  return -1;
+}
+
+/* Close FD on the target.  Return 0, or -1 if an error occurs
+   (and set *TARGET_ERRNO).  */
+int
+target_fileio_close (int fd, int *target_errno)
+{
+  struct target_ops *t;
+
+  for (t = default_fileio_target (); t != NULL; t = t->beneath)
+    {
+      if (t->to_fileio_close != NULL)
+        {
+          int ret = t->to_fileio_close (fd, target_errno);
+
+          if (targetdebug)
+            fprintf_unfiltered (gdb_stdlog,
+                                "target_fileio_close (%d) = %d (%d)\n",
+                                fd, ret, ret != -1 ? 0 : *target_errno);
+          return ret;
+        }
+    }
+
+  *target_errno = FILEIO_ENOSYS;
+  return -1;
+}
+
+/* Unlink FILENAME on the target.  Return 0, or -1 if an error
+   occurs (and set *TARGET_ERRNO).  */
+int
+target_fileio_unlink (const char *filename, int *target_errno)
+{
+  struct target_ops *t;
+
+  for (t = default_fileio_target (); t != NULL; t = t->beneath)
+    {
+      if (t->to_fileio_unlink != NULL)
+        {
+          int ret = t->to_fileio_unlink (filename, target_errno);
+
+          if (targetdebug)
+            fprintf_unfiltered (gdb_stdlog,
+                                "target_fileio_unlink (%s) = %d (%d)\n",
+                                filename, ret, ret != -1 ? 0 : *target_errno);
+          return ret;
+        }
+    }
+
+  *target_errno = FILEIO_ENOSYS;
+  return -1;
+}
+
+/* Read value of symbolic link FILENAME on the target.  Return a
+   null-terminated string allocated via xmalloc, or NULL if an error
+   occurs (and set *TARGET_ERRNO).  */
+char *
+target_fileio_readlink (const char *filename, int *target_errno)
+{
+  struct target_ops *t;
+
+  for (t = default_fileio_target (); t != NULL; t = t->beneath)
+    {
+      if (t->to_fileio_readlink != NULL)
+        {
+          char *ret = t->to_fileio_readlink (filename, target_errno);
+
+          if (targetdebug)
+            fprintf_unfiltered (gdb_stdlog,
+                                "target_fileio_readlink (%s) = %s (%d)\n",
+                                filename, ret? ret : "(nil)",
+                                ret? 0 : *target_errno);
+          return ret;
+        }
+    }
+
+  *target_errno = FILEIO_ENOSYS;
+  return NULL;
+}
+
+static void
+target_fileio_close_cleanup (void *opaque)
+{
+  int fd = *(int *) opaque;
+  int target_errno;
+
+  target_fileio_close (fd, &target_errno);
+}
+
+/* Read target file FILENAME.  Store the result in *BUF_P and
+   return the size of the transferred data.  PADDING additional bytes are
+   available in *BUF_P.  This is a helper function for
+   target_fileio_read_alloc; see the declaration of that function for more
+   information.  */
+
+static LONGEST
+target_fileio_read_alloc_1 (const char *filename,
+                            gdb_byte **buf_p, int padding)
+{
+  struct cleanup *close_cleanup;
+  size_t buf_alloc, buf_pos;
+  gdb_byte *buf;
+  LONGEST n;
+  int fd;
+  int target_errno;
+
+  fd = target_fileio_open (filename, FILEIO_O_RDONLY, 0700, &target_errno);
+  if (fd == -1)
+    return -1;
+
+  close_cleanup = make_cleanup (target_fileio_close_cleanup, &fd);
+
+  /* Start by reading up to 4K at a time.  The target will throttle
+     this number down if necessary.  */
+  buf_alloc = 4096;
+  buf = xmalloc (buf_alloc);
+  buf_pos = 0;
+  while (1)
+    {
+      n = target_fileio_pread (fd, &buf[buf_pos],
+                               buf_alloc - buf_pos - padding, buf_pos,
+                               &target_errno);
+      if (n < 0)
+        {
+          /* An error occurred.  */
+          do_cleanups (close_cleanup);
+          xfree (buf);
+          return -1;
+        }
+      else if (n == 0)
+        {
+          /* Read all there was.  */
+          do_cleanups (close_cleanup);
+          if (buf_pos == 0)
+            xfree (buf);
+          else
+            *buf_p = buf;
+          return buf_pos;
+        }
+
+      buf_pos += n;
+
+      /* If the buffer is filling up, expand it.  */
+      if (buf_alloc < buf_pos * 2)
+        {
+          buf_alloc *= 2;
+          buf = xrealloc (buf, buf_alloc);
+        }
+
+      QUIT;
+    }
+}
+
+/* Read target file FILENAME.  Store the result in *BUF_P and return
+   the size of the transferred data.  See the declaration in "target.h"
+   function for more information about the return value.  */
+
+LONGEST
+target_fileio_read_alloc (const char *filename, gdb_byte **buf_p)
+{
+  return target_fileio_read_alloc_1 (filename, buf_p, 0);
+}
+
+/* Read target file FILENAME.  The result is NUL-terminated and
+   returned as a string, allocated using xmalloc.  If an error occurs
+   or the transfer is unsupported, NULL is returned.  Empty objects
+   are returned as allocated but empty strings.  A warning is issued
+   if the result contains any embedded NUL bytes.  */
+
+char *
+target_fileio_read_stralloc (const char *filename)
+{
+  gdb_byte *buffer;
+  LONGEST i, transferred;
+
+  transferred = target_fileio_read_alloc_1 (filename, &buffer, 1);
+
+  if (transferred < 0)
+    return NULL;
+
+  if (transferred == 0)
+    return xstrdup ("");
+
+  buffer[transferred] = 0;
+
+  /* Check for embedded NUL bytes; but allow trailing NULs.  */
+  for (i = strlen (buffer); i < transferred; i++)
+    if (buffer[i] != 0)
+      {
+        warning (_("target file %s "
+                   "contained unexpected null characters"),
+                 filename);
+        break;
+      }
+
+  return (char *) buffer;
+}
+
+
 static int
 default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
 {
   return (len <= gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT);
 }
 
 static int
 default_watchpoint_addr_within_range (struct target_ops *target,
                                       CORE_ADDR addr,
                                       CORE_ADDR start, int length)
@@ skipping 60 matching lines @@
 }
 
 
 
 /* The inferior process has died.  Long live the inferior!  */
 
 void
 generic_mourn_inferior (void)
 {
   ptid_t ptid;