X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fi386gnu-nat.c;h=e14a181564fd819eafaa0408ee6bab42a97d620f;hb=f166f943f30a91792e8754cbca9d7652fc400aae;hp=82f9ee57647b7192e071cde5a1d4b6f7aecca489;hpb=8262ee2317b7e0652a3bce7d82f0606b573e79a1;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/i386gnu-nat.c b/gdb/i386gnu-nat.c
index 82f9ee5764..e14a181564 100644
--- a/gdb/i386gnu-nat.c
+++ b/gdb/i386gnu-nat.c
@@ -1,12 +1,12 @@
/* Low level interface to i386 running the GNU Hurd.
- Copyright 1992, 1995, 1996, 1998, 2000, 2001
- Free Software Foundation, Inc.
+
+ Copyright (C) 1992-2016 Free Software Foundation, Inc.
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 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,
@@ -15,19 +15,14 @@
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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see . */
#include "defs.h"
+#include "x86-nat.h"
#include "inferior.h"
#include "floatformat.h"
#include "regcache.h"
-#include "gdb_assert.h"
-#include
-#include
-
#include
#include
#include
@@ -36,13 +31,9 @@
#include "i386-tdep.h"
#include "gnu-nat.h"
+#include "inf-child.h"
#include "i387-tdep.h"
-#ifdef HAVE_SYS_PROCFS_H
-# include
-# include "gregset.h"
-#endif
-
/* Offset to the thread_state_t location where REG is stored. */
#define REG_OFFSET(reg) offsetof (struct i386_thread_state, reg)
@@ -59,10 +50,11 @@ static int reg_offset[] =
#define REG_ADDR(state, regnum) ((char *)(state) + reg_offset[regnum])
-/* Get the whole floating-point state of THREAD and record the
- values of the corresponding (pseudo) registers. */
+/* Get the whole floating-point state of THREAD and record the values
+ of the corresponding (pseudo) registers. */
+
static void
-fetch_fpregs (struct proc *thread)
+fetch_fpregs (struct regcache *regcache, struct proc *thread)
{
mach_msg_type_number_t count = i386_FLOAT_STATE_COUNT;
struct i386_float_state state;
@@ -72,57 +64,38 @@ fetch_fpregs (struct proc *thread)
(thread_state_t) &state, &count);
if (err)
{
- warning ("Couldn't fetch floating-point state from %s",
+ warning (_("Couldn't fetch floating-point state from %s"),
proc_string (thread));
return;
}
if (!state.initialized)
- /* The floating-point state isn't initialized. */
{
- int i;
-
- for (i = FP0_REGNUM; i <= FOP_REGNUM; i++)
- supply_register (i, NULL);
-
- return;
+ /* The floating-point state isn't initialized. */
+ i387_supply_fsave (regcache, -1, NULL);
+ }
+ else
+ {
+ /* Supply the floating-point registers. */
+ i387_supply_fsave (regcache, -1, state.hw_state);
}
-
- /* Supply the floating-point registers. */
- i387_supply_fsave (state.hw_state);
-}
-
-#ifdef HAVE_SYS_PROCFS_H
-/* These two calls are used by the core-regset.c code for
- reading ELF core files. */
-void
-supply_gregset (gdb_gregset_t *gregs)
-{
- int i;
- for (i = 0; i < I386_NUM_GREGS; i++)
- supply_register (i, REG_ADDR (gregs, i));
-}
-
-void
-supply_fpregset (gdb_fpregset_t *fpregs)
-{
- i387_supply_fsave ((char *) fpregs);
}
-#endif
/* Fetch register REGNO, or all regs if REGNO is -1. */
-void
-gnu_fetch_registers (int regno)
+static void
+gnu_fetch_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
struct proc *thread;
/* Make sure we know about new threads. */
- inf_update_procs (current_inferior);
+ inf_update_procs (gnu_current_inf);
- thread = inf_tid_to_thread (current_inferior, PIDGET (inferior_ptid));
+ thread = inf_tid_to_thread (gnu_current_inf,
+ ptid_get_lwp (inferior_ptid));
if (!thread)
- error ("Can't fetch registers from thread %d: No such thread",
- PIDGET (inferior_ptid));
+ error (_("Can't fetch registers from thread %s: No such thread"),
+ target_pid_to_str (inferior_ptid));
if (regno < I386_NUM_GREGS || regno == -1)
{
@@ -132,7 +105,7 @@ gnu_fetch_registers (int regno)
state = proc_get_state (thread, 0);
if (!state)
{
- warning ("Couldn't fetch registers from %s",
+ warning (_("Couldn't fetch registers from %s"),
proc_string (thread));
return;
}
@@ -144,14 +117,17 @@ gnu_fetch_registers (int regno)
proc_debug (thread, "fetching all register");
for (i = 0; i < I386_NUM_GREGS; i++)
- supply_register (i, REG_ADDR (state, i));
+ regcache_raw_supply (regcache, i, REG_ADDR (state, i));
thread->fetched_regs = ~0;
}
else
{
- proc_debug (thread, "fetching register %s", REGISTER_NAME (regno));
+ proc_debug (thread, "fetching register %s",
+ gdbarch_register_name (get_regcache_arch (regcache),
+ regno));
- supply_register (regno, REG_ADDR (state, regno));
+ regcache_raw_supply (regcache, regno,
+ REG_ADDR (state, regno));
thread->fetched_regs |= (1 << regno);
}
}
@@ -160,7 +136,7 @@ gnu_fetch_registers (int regno)
{
proc_debug (thread, "fetching floating-point registers");
- fetch_fpregs (thread);
+ fetch_fpregs (regcache, thread);
}
}
@@ -168,7 +144,7 @@ gnu_fetch_registers (int regno)
/* Store the whole floating-point state into THREAD using information
from the corresponding (pseudo) registers. */
static void
-store_fpregs (struct proc *thread, int regno)
+store_fpregs (const struct regcache *regcache, struct proc *thread, int regno)
{
mach_msg_type_number_t count = i386_FLOAT_STATE_COUNT;
struct i386_float_state state;
@@ -178,38 +154,41 @@ store_fpregs (struct proc *thread, int regno)
(thread_state_t) &state, &count);
if (err)
{
- warning ("Couldn't fetch floating-point state from %s",
+ warning (_("Couldn't fetch floating-point state from %s"),
proc_string (thread));
return;
}
/* FIXME: kettenis/2001-07-15: Is this right? Should we somehow
take into account DEPRECATED_REGISTER_VALID like the old code did? */
- i387_fill_fsave (state.hw_state, regno);
+ i387_collect_fsave (regcache, regno, state.hw_state);
err = thread_set_state (thread->port, i386_FLOAT_STATE,
(thread_state_t) &state, i386_FLOAT_STATE_COUNT);
if (err)
{
- warning ("Couldn't store floating-point state into %s",
+ warning (_("Couldn't store floating-point state into %s"),
proc_string (thread));
return;
}
}
/* Store at least register REGNO, or all regs if REGNO == -1. */
-void
-gnu_store_registers (int regno)
+static void
+gnu_store_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
struct proc *thread;
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
/* Make sure we know about new threads. */
- inf_update_procs (current_inferior);
+ inf_update_procs (gnu_current_inf);
- thread = inf_tid_to_thread (current_inferior, PIDGET (inferior_ptid));
+ thread = inf_tid_to_thread (gnu_current_inf,
+ ptid_get_lwp (inferior_ptid));
if (!thread)
- error ("Couldn't store registers into thread %d: No such thread",
- PIDGET (inferior_ptid));
+ error (_("Couldn't store registers into thread %s: No such thread"),
+ target_pid_to_str (inferior_ptid));
if (regno < I386_NUM_GREGS || regno == -1)
{
@@ -225,7 +204,8 @@ gnu_store_registers (int regno)
state = proc_get_state (thread, 1);
if (!state)
{
- warning ("Couldn't store registers into %s", proc_string (thread));
+ warning (_("Couldn't store registers into %s"),
+ proc_string (thread));
return;
}
@@ -242,23 +222,21 @@ gnu_store_registers (int regno)
if ((thread->fetched_regs & (1 << check_regno))
&& memcpy (REG_ADDR (&old_state, check_regno),
REG_ADDR (state, check_regno),
- REGISTER_RAW_SIZE (check_regno)))
+ register_size (gdbarch, check_regno)))
/* Register CHECK_REGNO has changed! Ack! */
{
- warning ("Register %s changed after the thread was aborted",
- REGISTER_NAME (check_regno));
+ warning (_("Register %s changed after the thread was aborted"),
+ gdbarch_register_name (gdbarch, check_regno));
if (regno >= 0 && regno != check_regno)
/* Update GDB's copy of the register. */
- supply_register (check_regno, REG_ADDR (state, check_regno));
+ regcache_raw_supply (regcache, check_regno,
+ REG_ADDR (state, check_regno));
else
- warning ("... also writing this register! Suspicious...");
+ warning (_("... also writing this register! "
+ "Suspicious..."));
}
}
-#define fill(state, regno) \
- memcpy (REG_ADDR(state, regno), ®isters[REGISTER_BYTE (regno)], \
- REGISTER_RAW_SIZE (regno))
-
if (regno == -1)
{
int i;
@@ -266,15 +244,16 @@ gnu_store_registers (int regno)
proc_debug (thread, "storing all registers");
for (i = 0; i < I386_NUM_GREGS; i++)
- if (deprecated_register_valid[i])
- fill (state, i);
+ if (REG_VALID == regcache_register_status (regcache, i))
+ regcache_raw_collect (regcache, i, REG_ADDR (state, i));
}
else
{
- proc_debug (thread, "storing register %s", REGISTER_NAME (regno));
+ proc_debug (thread, "storing register %s",
+ gdbarch_register_name (gdbarch, regno));
- gdb_assert (deprecated_register_valid[regno]);
- fill (state, regno);
+ gdb_assert (REG_VALID == regcache_register_status (regcache, regno));
+ regcache_raw_collect (regcache, regno, REG_ADDR (state, regno));
}
/* Restore the T bit. */
@@ -282,12 +261,176 @@ gnu_store_registers (int regno)
((struct i386_thread_state *)state)->efl |= trace;
}
-#undef fill
-
if (regno >= I386_NUM_GREGS || regno == -1)
{
proc_debug (thread, "storing floating-point registers");
- store_fpregs (thread, regno);
+ store_fpregs (regcache, thread, regno);
}
}
+
+
+/* Support for debug registers. */
+
+#ifdef i386_DEBUG_STATE
+/* Get debug registers for thread THREAD. */
+
+static void
+i386_gnu_dr_get (struct i386_debug_state *regs, struct proc *thread)
+{
+ mach_msg_type_number_t count = i386_DEBUG_STATE_COUNT;
+ error_t err;
+
+ err = thread_get_state (thread->port, i386_DEBUG_STATE,
+ (thread_state_t) regs, &count);
+ if (err != 0 || count != i386_DEBUG_STATE_COUNT)
+ warning (_("Couldn't fetch debug state from %s"),
+ proc_string (thread));
+}
+
+/* Set debug registers for thread THREAD. */
+
+static void
+i386_gnu_dr_set (const struct i386_debug_state *regs, struct proc *thread)
+{
+ error_t err;
+
+ err = thread_set_state (thread->port, i386_DEBUG_STATE,
+ (thread_state_t) regs, i386_DEBUG_STATE_COUNT);
+ if (err != 0)
+ warning (_("Couldn't store debug state into %s"),
+ proc_string (thread));
+}
+
+/* Set DR_CONTROL in THREAD. */
+
+static void
+i386_gnu_dr_set_control_one (struct proc *thread, void *arg)
+{
+ unsigned long *control = arg;
+ struct i386_debug_state regs;
+
+ i386_gnu_dr_get (®s, thread);
+ regs.dr[DR_CONTROL] = *control;
+ i386_gnu_dr_set (®s, thread);
+}
+
+/* Set DR_CONTROL to CONTROL in all threads. */
+
+static void
+i386_gnu_dr_set_control (unsigned long control)
+{
+ inf_update_procs (gnu_current_inf);
+ inf_threads (gnu_current_inf, i386_gnu_dr_set_control_one, &control);
+}
+
+/* Parameters to set a debugging address. */
+
+struct reg_addr
+{
+ int regnum; /* Register number (zero based). */
+ CORE_ADDR addr; /* Address. */
+};
+
+/* Set address REGNUM (zero based) to ADDR in THREAD. */
+
+static void
+i386_gnu_dr_set_addr_one (struct proc *thread, void *arg)
+{
+ struct reg_addr *reg_addr = arg;
+ struct i386_debug_state regs;
+
+ i386_gnu_dr_get (®s, thread);
+ regs.dr[reg_addr->regnum] = reg_addr->addr;
+ i386_gnu_dr_set (®s, thread);
+}
+
+/* Set address REGNUM (zero based) to ADDR in all threads. */
+
+static void
+i386_gnu_dr_set_addr (int regnum, CORE_ADDR addr)
+{
+ struct reg_addr reg_addr;
+
+ gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
+
+ reg_addr.regnum = regnum;
+ reg_addr.addr = addr;
+
+ inf_update_procs (gnu_current_inf);
+ inf_threads (gnu_current_inf, i386_gnu_dr_set_addr_one, ®_addr);
+}
+
+/* Get debug register REGNUM value from only the one LWP of PTID. */
+
+static unsigned long
+i386_gnu_dr_get_reg (ptid_t ptid, int regnum)
+{
+ struct i386_debug_state regs;
+ struct proc *thread;
+
+ /* Make sure we know about new threads. */
+ inf_update_procs (gnu_current_inf);
+
+ thread = inf_tid_to_thread (gnu_current_inf, ptid_get_lwp (ptid));
+ i386_gnu_dr_get (®s, thread);
+
+ return regs.dr[regnum];
+}
+
+/* Return the inferior's debug register REGNUM. */
+
+static CORE_ADDR
+i386_gnu_dr_get_addr (int regnum)
+{
+ gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
+
+ return i386_gnu_dr_get_reg (inferior_ptid, regnum);
+}
+
+/* Get DR_STATUS from only the one thread of INFERIOR_PTID. */
+
+static unsigned long
+i386_gnu_dr_get_status (void)
+{
+ return i386_gnu_dr_get_reg (inferior_ptid, DR_STATUS);
+}
+
+/* Return the inferior's DR7 debug control register. */
+
+static unsigned long
+i386_gnu_dr_get_control (void)
+{
+ return i386_gnu_dr_get_reg (inferior_ptid, DR_CONTROL);
+}
+#endif /* i386_DEBUG_STATE */
+
+/* Provide a prototype to silence -Wmissing-prototypes. */
+extern initialize_file_ftype _initialize_i386gnu_nat;
+
+void
+_initialize_i386gnu_nat (void)
+{
+ struct target_ops *t;
+
+ /* Fill in the generic GNU/Hurd methods. */
+ t = gnu_target ();
+
+#ifdef i386_DEBUG_STATE
+ x86_use_watchpoints (t);
+
+ x86_dr_low.set_control = i386_gnu_dr_set_control;
+ gdb_assert (DR_FIRSTADDR == 0 && DR_LASTADDR < i386_DEBUG_STATE_COUNT);
+ x86_dr_low.set_addr = i386_gnu_dr_set_addr;
+ x86_dr_low.get_addr = i386_gnu_dr_get_addr;
+ x86_dr_low.get_status = i386_gnu_dr_get_status;
+ x86_dr_low.get_control = i386_gnu_dr_get_control;
+ x86_set_debug_register_length (4);
+#endif /* i386_DEBUG_STATE */
+
+ t->to_fetch_registers = gnu_fetch_registers;
+ t->to_store_registers = gnu_store_registers;
+
+ /* Register the target. */
+ add_target (t);
+}