/* Machine independent support for SVR4 /proc (process file system) for GDB.
- Copyright (C) 1999-2003, 2006-2012 Free Software Foundation, Inc.
+ Copyright (C) 1999-2013 Free Software Foundation, Inc.
Written by Michael Snyder at Cygnus Solutions.
Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
#include "gdb_wait.h"
#include <signal.h>
#include <ctype.h>
+#include "gdb_bfd.h"
#include "gdb_string.h"
#include "gdb_assert.h"
#include "inflow.h"
Irix
Solaris
OSF
- Unixware
AIX5
/proc works by imitating a file system: you open a simulated file
static void procfs_attach (struct target_ops *, char *, int);
static void procfs_detach (struct target_ops *, char *, int);
static void procfs_resume (struct target_ops *,
- ptid_t, int, enum target_signal);
+ ptid_t, int, enum gdb_signal);
static void procfs_stop (ptid_t);
static void procfs_files_info (struct target_ops *);
static void procfs_fetch_registers (struct target_ops *,
static void procfs_find_new_threads (struct target_ops *ops);
static char *procfs_pid_to_str (struct target_ops *, ptid_t);
-static int proc_find_memory_regions (int (*) (CORE_ADDR,
- unsigned long,
- int, int, int,
- void *),
- void *);
+static int proc_find_memory_regions (find_memory_region_ftype, void *);
static char * procfs_make_note_section (bfd *, int *);
procfs_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
{
- enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
gdb_byte *ptr = *readptr;
if (endptr == ptr)
/* This function is getting ALMOST long enough to break up into
several. Here is some rationale:
- NEW_PROC_API (Solaris 2.6, Solaris 2.7, Unixware):
+ NEW_PROC_API (Solaris 2.6, Solaris 2.7):
There are several file descriptors that may need to be open
for any given process or LWP. The ones we're intereted in are:
- control (ctl) write-only change the state
(char *) &pi->prstatus,
sizeof (gdb_prstatus_t))
== sizeof (gdb_prstatus_t));
-#if 0 /*def UNIXWARE*/
- if (pi->status_valid &&
- (pi->prstatus.pr_lwp.pr_flags & PR_ISTOP) &&
- pi->prstatus.pr_lwp.pr_why == PR_REQUESTED)
- /* Unixware peculiarity -- read the damn thing again! */
- pi->status_valid = (read (pi->status_fd,
- (char *) &pi->prstatus,
- sizeof (gdb_prstatus_t))
- == sizeof (gdb_prstatus_t));
-#endif /* UNIXWARE */
}
}
#else /* ioctl method */
return 0; /* FIXME: not a good failure value (but what is?) */
#ifdef NEW_PROC_API
-# ifdef UNIXWARE
- /* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
- pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
- The two sets of flags don't overlap. */
- return pi->prstatus.pr_flags | pi->prstatus.pr_lwp.pr_flags;
-# else
return pi->prstatus.pr_lwp.pr_flags;
-# endif
#else
return pi->prstatus.pr_flags;
#endif
return 0;
#ifdef NEW_PROC_API
- *addr = (CORE_ADDR) gdbarch_pointer_to_address (target_gdbarch,
- builtin_type (target_gdbarch)->builtin_data_ptr,
+ *addr = (CORE_ADDR) gdbarch_pointer_to_address (target_gdbarch (),
+ builtin_type (target_gdbarch ())->builtin_data_ptr,
(gdb_byte *) &pi->prstatus.pr_lwp.pr_info.si_addr);
#else
- *addr = (CORE_ADDR) gdbarch_pointer_to_address (target_gdbarch,
- builtin_type (target_gdbarch)->builtin_data_ptr,
+ *addr = (CORE_ADDR) gdbarch_pointer_to_address (target_gdbarch (),
+ builtin_type (target_gdbarch ())->builtin_data_ptr,
(gdb_byte *) &pi->prstatus.pr_info.si_addr);
#endif
return 1;
if (pi->pid != 0)
pi = find_procinfo_or_die (pi->pid, 0);
-#ifdef NEW_PROC_API /* Newest method: UnixWare and newer Solarii. */
+#ifdef NEW_PROC_API /* Newest method: Newer Solarii. */
/* First normalize the PCUNSET/PCRESET command opcode
(which for no obvious reason has a different definition
from one operating system to the next...) */
if (!proc_get_status (pi))
return NULL;
-#ifdef UNIXWARE
- ret = &pi->prstatus.pr_lwp.pr_context.uc_sigmask;
-#else
ret = &pi->prstatus.pr_lwp.pr_lwphold;
-#endif /* UNIXWARE */
#else /* not NEW_PROC_API */
{
static gdb_sigset_t sigheld;
get_last_target_status (&wait_ptid, &wait_status);
if (ptid_equal (wait_ptid, inferior_ptid)
&& wait_status.kind == TARGET_WAITKIND_STOPPED
- && wait_status.value.sig == target_signal_from_host (signo)
+ && wait_status.value.sig == gdb_signal_from_host (signo)
&& proc_get_status (pi)
#ifdef NEW_PROC_API
&& pi->prstatus.pr_lwp.pr_info.si_signo == signo
if (!proc_get_status (pi))
return NULL;
- /* OK, sorry about the ifdef's. There's three cases instead of two,
- because in this case Unixware and Solaris/RW differ. */
-
#ifdef NEW_PROC_API
-# ifdef UNIXWARE /* FIXME: Should be autoconfigured. */
- return &pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs;
-# else
return &pi->prstatus.pr_lwp.pr_reg;
-# endif
#else
return &pi->prstatus.pr_reg;
#endif
if (!proc_get_status (pi))
return NULL;
-# ifdef UNIXWARE /* FIXME: Should be autoconfigured. */
- return &pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs;
-# else
return &pi->prstatus.pr_lwp.pr_fpreg;
-# endif
#else /* not NEW_PROC_API */
if (pi->fpregs_valid)
(a.k.a void pointer)! */
#if (defined (PCWATCH) || defined (PIOCSWATCH)) \
- && !(defined (PIOCOPENLWP) || defined (UNIXWARE))
+ && !(defined (PIOCOPENLWP))
static void *
procfs_address_to_host_pointer (CORE_ADDR addr)
{
- struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+ struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
void *ptr;
gdb_assert (sizeof (ptr) == TYPE_LENGTH (ptr_type));
- gdbarch_address_to_pointer (target_gdbarch, ptr_type,
+ gdbarch_address_to_pointer (target_gdbarch (), ptr_type,
(gdb_byte *) &ptr, addr);
return ptr;
}
return 0;
#else
/* Horrible hack! Detect Solaris 2.5, because this doesn't work on 2.5. */
-#if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out. */
+#if defined (PIOCOPENLWP) /* Solaris 2.5: bail out. */
return 0;
#else
struct {
register for the LWP that we're interested in. Returns the
matching ssh struct (LDT entry). */
-struct ssd *
+static struct ssd *
proc_get_LDT_entry (procinfo *pi, int key)
{
static struct ssd *ldt_entry = NULL;
#else
#if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
-/* Solaris and Unixware version */
+/* Solaris version */
static int
proc_get_nthreads (procinfo *pi)
{
currently executing. */
#if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
-/* Solaris and Unixware version */
+/* Solaris version */
static int
proc_get_current_thread (procinfo *pi)
{
}
#else
#ifdef NEW_PROC_API
-/* Unixware and Solaris 6 (and later) version. */
+/* Solaris 6 (and later) version. */
static void
do_closedir_cleanup (void *dir)
{
proc_iterate_over_threads (pi, proc_delete_dead_threads, NULL);
- /* Unixware
-
- Note: this brute-force method is the only way I know of to
- accomplish this task on Unixware. This method will also work on
- Solaris 2.6 and 2.7. There is a much simpler and more elegant
- way to do this on Solaris, but the margins of this manuscript are
- too small to write it here... ;-) */
+ /* Note: this brute-force method was originally devised for Unixware
+ (support removed since), and will also work on Solaris 2.6 and
+ 2.7. The original comment mentioned the existence of a much
+ simpler and more elegant way to do this on Solaris, but didn't
+ point out what that was. */
strcpy (pathname, pi->pathname);
strcat (pathname, "/lwp");
if (dbx_link_bpt_addr == 0)
return;
- if (deprecated_remove_raw_breakpoint (target_gdbarch, dbx_link_bpt) != 0)
+ if (deprecated_remove_raw_breakpoint (target_gdbarch (), dbx_link_bpt) != 0)
warning (_("Unable to remove __dbx_link breakpoint."));
dbx_link_bpt_addr = 0;
long storage_needed;
CORE_ADDR sym_addr;
- abfd = bfd_fdopenr ("unamed", 0, fd);
+ abfd = gdb_bfd_fdopenr ("unamed", 0, fd);
if (abfd == NULL)
{
warning (_("Failed to create a bfd: %s."), bfd_errmsg (bfd_get_error ()));
{
/* Not the correct format, so we can not possibly find the dbx_link
symbol in it. */
- bfd_close (abfd);
+ gdb_bfd_unref (abfd);
return 0;
}
{
/* Insert the breakpoint. */
dbx_link_bpt_addr = sym_addr;
- dbx_link_bpt = deprecated_insert_raw_breakpoint (target_gdbarch, NULL,
+ dbx_link_bpt = deprecated_insert_raw_breakpoint (target_gdbarch (), NULL,
sym_addr);
if (dbx_link_bpt == NULL)
{
warning (_("Failed to insert dbx_link breakpoint."));
- bfd_close (abfd);
+ gdb_bfd_unref (abfd);
return 0;
}
- bfd_close (abfd);
+ gdb_bfd_unref (abfd);
return 1;
}
- bfd_close (abfd);
+ gdb_bfd_unref (abfd);
return 0;
}
else
{
/* How to keep going without returning to wfi: */
- target_resume (ptid, 0, TARGET_SIGNAL_0);
+ target_resume (ptid, 0, GDB_SIGNAL_0);
goto wait_again;
}
}
/* This is an internal event and should be transparent
to wfi, so resume the execution and wait again. See
comment in procfs_init_inferior() for more details. */
- target_resume (ptid, 0, TARGET_SIGNAL_0);
+ target_resume (ptid, 0, GDB_SIGNAL_0);
goto wait_again;
}
#endif
if (!proc_set_gregs (pi)) /* flush gregs cache */
proc_warn (pi, "target_resume, set_gregs",
__LINE__);
- if (gdbarch_fp0_regnum (target_gdbarch) >= 0)
+ if (gdbarch_fp0_regnum (target_gdbarch ()) >= 0)
if (pi->fpregs_dirty)
if (parent == NULL ||
proc_get_current_thread (parent) != pi->tid)
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)
{
procinfo *pi, *thread;
int native_signo;
/* Convert signal to host numbering. */
if (signo == 0 ||
- (signo == TARGET_SIGNAL_STOP && pi->ignore_next_sigstop))
+ (signo == GDB_SIGNAL_STOP && pi->ignore_next_sigstop))
native_signo = 0;
else
- native_signo = target_signal_to_host (signo);
+ native_signo = gdb_signal_to_host (signo);
pi->ignore_next_sigstop = 0;
for (signo = 0; 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])
gdb_prdelset (&signals, signo);
}
if (dbx_link_bpt != NULL)
{
- deprecated_remove_raw_breakpoint (target_gdbarch, dbx_link_bpt);
+ deprecated_remove_raw_breakpoint (target_gdbarch (), dbx_link_bpt);
dbx_link_bpt_addr = 0;
dbx_link_bpt = NULL;
}
procfs_set_watchpoint (ptid_t ptid, CORE_ADDR addr, int len, int rwflag,
int after)
{
-#ifndef UNIXWARE
#ifndef AIX5
int pflags = 0;
procinfo *pi;
proc_error (pi, "set_watchpoint", __LINE__);
}
#endif /* AIX5 */
-#endif /* UNIXWARE */
return 0;
}
procfs_address_to_host_pointer will reveal that an internal error
will be generated when the host and target pointer sizes are
different. */
- struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+ struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
if (sizeof (void *) != TYPE_LENGTH (ptr_type))
return 0;
struct expression *cond)
{
if (!target_have_steppable_watchpoint
- && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch))
+ && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch ()))
{
/* When a hardware watchpoint fires off the PC will be left at
the instruction following the one which caused the
(map->pr_mflags & MA_READ) != 0,
(map->pr_mflags & MA_WRITE) != 0,
(map->pr_mflags & MA_EXEC) != 0,
+ 1, /* MODIFIED is unknown, pass it as true. */
data);
}
pr_off = map->pr_off;
#endif
- if (gdbarch_addr_bit (target_gdbarch) == 32)
+ if (gdbarch_addr_bit (target_gdbarch ()) == 32)
printf_filtered ("\t%#10lx %#10lx %#10lx %#10x %7s\n",
(unsigned long) map->pr_vaddr,
(unsigned long) map->pr_vaddr + map->pr_size - 1,
return; /* No output for summary mode. */
printf_filtered (_("Mapped address spaces:\n\n"));
- if (gdbarch_ptr_bit (target_gdbarch) == 32)
+ if (gdbarch_ptr_bit (target_gdbarch ()) == 32)
printf_filtered ("\t%10s %10s %10s %10s %7s\n",
"Start Addr",
" End Addr",
}
/* =================== GCORE .NOTE "MODULE" =================== */
-#if defined (UNIXWARE) || defined (PIOCOPENLWP) || defined (PCAGENT)
-/* gcore only implemented on solaris and unixware (so far) */
+#if defined (PIOCOPENLWP) || defined (PCAGENT)
+/* gcore only implemented on solaris (so far) */
static char *
procfs_do_thread_registers (bfd *obfd, ptid_t ptid,
char *note_data, int *note_size,
- enum target_signal stop_signal)
+ enum gdb_signal stop_signal)
{
struct regcache *regcache = get_thread_regcache (ptid);
gdb_gregset_t gregs;
bfd *obfd;
char *note_data;
int *note_size;
- enum target_signal stop_signal;
+ enum gdb_signal stop_signal;
};
static int
static int
find_signalled_thread (struct thread_info *info, void *data)
{
- if (info->suspend.stop_signal != TARGET_SIGNAL_0
+ if (info->suspend.stop_signal != GDB_SIGNAL_0
&& ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
return 1;
return 0;
}
-static enum target_signal
+static enum gdb_signal
find_stop_signal (void)
{
struct thread_info *info =
if (info)
return info->suspend.stop_signal;
else
- return TARGET_SIGNAL_0;
+ return GDB_SIGNAL_0;
}
static char *
struct procfs_corefile_thread_data thread_args;
gdb_byte *auxv;
int auxv_len;
- enum target_signal stop_signal;
+ enum gdb_signal stop_signal;
if (get_exec_file (0))
{
stop_signal = find_stop_signal ();
-#ifdef UNIXWARE
+#ifdef NEW_PROC_API
fill_gregset (get_current_regcache (), &gregs, -1);
note_data = elfcore_write_pstatus (obfd, note_data, note_size,
PIDGET (inferior_ptid),
make_cleanup (xfree, note_data);
return note_data;
}
-#else /* !(Solaris or Unixware) */
+#else /* !Solaris */
static char *
procfs_make_note_section (bfd *obfd, int *note_size)
{
error (_("gcore not implemented for this host."));
return NULL; /* lint */
}
-#endif /* Solaris or Unixware */
+#endif /* Solaris */
/* =================== END GCORE .NOTE "MODULE" =================== */
projects / deliverable / binutils-gdb.git / blobdiff