X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fi386gnu-nat.c;h=104a7137d2edfc1399d3ad46499ab8b2ed0b3fd4;hb=4ee62156d969867d3d3ffedf656a74643f77279e;hp=023fbb7d6e8650ccefa2b3ea57c012c3fe092b5b;hpb=3303a2761a3f8b2c2a9e1c683a5f43fae5625be3;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/i386gnu-nat.c b/gdb/i386gnu-nat.c index 023fbb7d6e..104a7137d2 100644 --- a/gdb/i386gnu-nat.c +++ b/gdb/i386gnu-nat.c @@ -1,13 +1,13 @@ /* Low level interface to i386 running the GNU Hurd. - Copyright 1992, 1995, 1996, 1998, 2000, 2001, 2004 + Copyright (C) 1992, 1995, 1996, 1998, 2000, 2001, 2004, 2007, 2008, 2009 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, @@ -16,9 +16,7 @@ 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 "inferior.h" @@ -59,13 +57,14 @@ static int reg_offset[] = }; #define REG_ADDR(state, regnum) ((char *)(state) + reg_offset[regnum]) +#define CREG_ADDR(state, regnum) ((const char *)(state) + reg_offset[regnum]) /* 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; @@ -75,7 +74,7 @@ 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; } @@ -83,12 +82,12 @@ fetch_fpregs (struct proc *thread) if (!state.initialized) { /* The floating-point state isn't initialized. */ - i387_supply_fsave (current_regcache, -1, NULL); + i387_supply_fsave (regcache, -1, NULL); } else { /* Supply the floating-point registers. */ - i387_supply_fsave (current_regcache, -1, state.hw_state); + i387_supply_fsave (regcache, -1, state.hw_state); } } @@ -96,33 +95,35 @@ fetch_fpregs (struct proc *thread) /* These two calls are used by the core-regset.c code for reading ELF core files. */ void -supply_gregset (gdb_gregset_t *gregs) +supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregs) { int i; for (i = 0; i < I386_NUM_GREGS; i++) - regcache_raw_supply (current_regcache, i, REG_ADDR (gregs, i)); + regcache_raw_supply (regcache, i, CREG_ADDR (gregs, i)); } void -supply_fpregset (gdb_fpregset_t *fpregs) +supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregs) { - i387_supply_fsave (current_regcache, -1, fpregs); + i387_supply_fsave (regcache, -1, 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_tid (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 +133,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 +145,16 @@ gnu_fetch_registers (int regno) proc_debug (thread, "fetching all register"); for (i = 0; i < I386_NUM_GREGS; i++) - regcache_raw_supply (current_regcache, 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)); - regcache_raw_supply (current_regcache, regno, + regcache_raw_supply (regcache, regno, REG_ADDR (state, regno)); thread->fetched_regs |= (1 << regno); } @@ -161,7 +164,7 @@ gnu_fetch_registers (int regno) { proc_debug (thread, "fetching floating-point registers"); - fetch_fpregs (thread); + fetch_fpregs (regcache, thread); } } @@ -169,7 +172,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; @@ -179,39 +182,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 regcache *regcache = current_regcache; 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_tid (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) { @@ -227,7 +232,7 @@ 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; } @@ -244,17 +249,17 @@ 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_size (current_gdbarch, 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. */ regcache_raw_supply (regcache, check_regno, REG_ADDR (state, check_regno)); else - warning ("... also writing this register! Suspicious..."); + warning (_("... also writing this register! Suspicious...")); } } @@ -270,7 +275,8 @@ gnu_store_registers (int regno) } else { - proc_debug (thread, "storing register %s", REGISTER_NAME (regno)); + proc_debug (thread, "storing register %s", + gdbarch_register_name (gdbarch, regno)); gdb_assert (regcache_valid_p (regcache, regno)); regcache_raw_collect (regcache, regno, REG_ADDR (state, regno)); @@ -285,6 +291,24 @@ gnu_store_registers (int regno) { proc_debug (thread, "storing floating-point registers"); - store_fpregs (thread, regno); + store_fpregs (regcache, thread, regno); } } + +/* 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 (); + + t->to_fetch_registers = gnu_fetch_registers; + t->to_store_registers = gnu_store_registers; + + /* Register the target. */ + add_target (t); +}