X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=gdb%2Fia64-linux-nat.c;h=e8ffc89eb566558816c6e019b61a7e176536dd2f;hb=4543ed4ff624db1929a68f9a61c52c5e3882655a;hp=8207be41cdecc7b6583ac0495b1641ca3c07758c;hpb=429c3ede5494ac51af6cbe60dfe46caffe378bf0;p=pf3gnuchains%2Fpf3gnuchains3x.git diff --git a/gdb/ia64-linux-nat.c b/gdb/ia64-linux-nat.c index 8207be41cd..e8ffc89eb5 100644 --- a/gdb/ia64-linux-nat.c +++ b/gdb/ia64-linux-nat.c @@ -1,14 +1,14 @@ /* Functions specific to running gdb native on IA-64 running GNU/Linux. - Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 - Free Software Foundation, Inc. + Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 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, @@ -17,9 +17,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., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ + along with this program. If not, see . */ #include "defs.h" #include "gdb_string.h" @@ -304,11 +302,11 @@ static int u_offsets[] = }; static CORE_ADDR -ia64_register_addr (int regno) +ia64_register_addr (struct gdbarch *gdbarch, int regno) { CORE_ADDR addr; - if (regno < 0 || regno >= NUM_REGS) + if (regno < 0 || regno >= gdbarch_num_regs (gdbarch)) error (_("Invalid register number %d."), regno); if (u_offsets[regno] == -1) @@ -320,13 +318,15 @@ ia64_register_addr (int regno) } static int -ia64_cannot_fetch_register (int regno) +ia64_cannot_fetch_register (struct gdbarch *gdbarch, int regno) { - return regno < 0 || regno >= NUM_REGS || u_offsets[regno] == -1; + return regno < 0 + || regno >= gdbarch_num_regs (gdbarch) + || u_offsets[regno] == -1; } static int -ia64_cannot_store_register (int regno) +ia64_cannot_store_register (struct gdbarch *gdbarch, int regno) { /* Rationale behind not permitting stores to bspstore... @@ -357,7 +357,9 @@ ia64_cannot_store_register (int regno) were previously read from the inferior process to be written back.) */ - return regno < 0 || regno >= NUM_REGS || u_offsets[regno] == -1 + return regno < 0 + || regno >= gdbarch_num_regs (gdbarch) + || u_offsets[regno] == -1 || regno == IA64_BSPSTORE_REGNUM; } @@ -479,31 +481,19 @@ fill_fpregset (const struct regcache *regcache, static void enable_watchpoints_in_psr (ptid_t ptid) { - CORE_ADDR psr; + struct regcache *regcache = get_thread_regcache (ptid); + ULONGEST psr; - psr = read_register_pid (IA64_PSR_REGNUM, ptid); + regcache_cooked_read_unsigned (regcache, IA64_PSR_REGNUM, &psr); if (!(psr & IA64_PSR_DB)) { psr |= IA64_PSR_DB; /* Set the db bit - this enables hardware watchpoints and breakpoints. */ - write_register_pid (IA64_PSR_REGNUM, psr, ptid); + regcache_cooked_write_unsigned (regcache, IA64_PSR_REGNUM, psr); } } -static long -fetch_debug_register (ptid_t ptid, int idx) -{ - long val; - int tid; - - tid = TIDGET (ptid); - if (tid == 0) - tid = PIDGET (ptid); - - val = ptrace (PT_READ_U, tid, (PTRACE_TYPE_ARG3) (PT_DBR + 8 * idx), 0); - - return val; -} +static long debug_registers[8]; static void store_debug_register (ptid_t ptid, int idx, long val) @@ -518,15 +508,6 @@ store_debug_register (ptid_t ptid, int idx, long val) } static void -fetch_debug_register_pair (ptid_t ptid, int idx, long *dbr_addr, long *dbr_mask) -{ - if (dbr_addr) - *dbr_addr = fetch_debug_register (ptid, 2 * idx); - if (dbr_mask) - *dbr_mask = fetch_debug_register (ptid, 2 * idx + 1); -} - -static void store_debug_register_pair (ptid_t ptid, int idx, long *dbr_addr, long *dbr_mask) { if (dbr_addr) @@ -551,7 +532,8 @@ is_power_of_2 (int val) static int ia64_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw) { - ptid_t ptid = inferior_ptid; + struct lwp_info *lp; + ptid_t ptid; int idx; long dbr_addr, dbr_mask; int max_watchpoints = 4; @@ -561,7 +543,7 @@ ia64_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw) for (idx = 0; idx < max_watchpoints; idx++) { - fetch_debug_register_pair (ptid, idx, NULL, &dbr_mask); + dbr_mask = debug_registers[idx * 2 + 1]; if ((dbr_mask & (0x3UL << 62)) == 0) { /* Exit loop if both r and w bits clear */ @@ -590,8 +572,13 @@ ia64_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw) return -1; } - store_debug_register_pair (ptid, idx, &dbr_addr, &dbr_mask); - enable_watchpoints_in_psr (ptid); + debug_registers[2 * idx] = dbr_addr; + debug_registers[2 * idx + 1] = dbr_mask; + ALL_LWPS (lp, ptid) + { + store_debug_register_pair (ptid, idx, &dbr_addr, &dbr_mask); + enable_watchpoints_in_psr (ptid); + } return 0; } @@ -599,7 +586,6 @@ ia64_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw) static int ia64_linux_remove_watchpoint (CORE_ADDR addr, int len, int type) { - ptid_t ptid = inferior_ptid; int idx; long dbr_addr, dbr_mask; int max_watchpoints = 4; @@ -609,43 +595,63 @@ ia64_linux_remove_watchpoint (CORE_ADDR addr, int len, int type) for (idx = 0; idx < max_watchpoints; idx++) { - fetch_debug_register_pair (ptid, idx, &dbr_addr, &dbr_mask); + dbr_addr = debug_registers[2 * idx]; + dbr_mask = debug_registers[2 * idx + 1]; if ((dbr_mask & (0x3UL << 62)) && addr == (CORE_ADDR) dbr_addr) { + struct lwp_info *lp; + ptid_t ptid; + + debug_registers[2 * idx] = 0; + debug_registers[2 * idx + 1] = 0; dbr_addr = 0; dbr_mask = 0; - store_debug_register_pair (ptid, idx, &dbr_addr, &dbr_mask); + + ALL_LWPS (lp, ptid) + store_debug_register_pair (ptid, idx, &dbr_addr, &dbr_mask); + return 0; } } return -1; } +static void +ia64_linux_new_thread (ptid_t ptid) +{ + int i, any; + + any = 0; + for (i = 0; i < 8; i++) + { + if (debug_registers[i] != 0) + any = 1; + store_debug_register (ptid, i, debug_registers[i]); + } + + if (any) + enable_watchpoints_in_psr (ptid); +} + static int ia64_linux_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p) { CORE_ADDR psr; - int tid; - struct siginfo siginfo; - ptid_t ptid = inferior_ptid; + struct siginfo *siginfo_p; + struct regcache *regcache = get_current_regcache (); - tid = TIDGET(ptid); - if (tid == 0) - tid = PIDGET (ptid); - - errno = 0; - ptrace (PTRACE_GETSIGINFO, tid, (PTRACE_TYPE_ARG3) 0, &siginfo); + siginfo_p = linux_nat_get_siginfo (inferior_ptid); - if (errno != 0 || siginfo.si_signo != SIGTRAP || - (siginfo.si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */) + if (siginfo_p->si_signo != SIGTRAP + || (siginfo_p->si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */) return 0; - psr = read_register_pid (IA64_PSR_REGNUM, ptid); + regcache_cooked_read_unsigned (regcache, IA64_PSR_REGNUM, &psr); psr |= IA64_PSR_DD; /* Set the dd bit - this will disable the watchpoint for the next instruction */ - write_register_pid (IA64_PSR_REGNUM, psr, ptid); + regcache_cooked_write_unsigned (regcache, IA64_PSR_REGNUM, psr); - *addr_p = (CORE_ADDR)siginfo.si_addr; + *addr_p = (CORE_ADDR)siginfo_p->si_addr; return 1; } @@ -666,16 +672,17 @@ ia64_linux_can_use_hw_breakpoint (int type, int cnt, int othertype) /* Fetch register REGNUM from the inferior. */ static void -ia64_linux_fetch_register (int regnum) +ia64_linux_fetch_register (struct regcache *regcache, int regnum) { + struct gdbarch *gdbarch = get_regcache_arch (regcache); CORE_ADDR addr; size_t size; PTRACE_TYPE_RET *buf; int pid, i; - if (ia64_cannot_fetch_register (regnum)) + if (ia64_cannot_fetch_register (gdbarch, regnum)) { - regcache_raw_supply (current_regcache, regnum, NULL); + regcache_raw_supply (regcache, regnum, NULL); return; } @@ -686,8 +693,8 @@ ia64_linux_fetch_register (int regnum) pid = ptid_get_pid (inferior_ptid); /* This isn't really an address, but ptrace thinks of it as one. */ - addr = ia64_register_addr (regnum); - size = register_size (current_gdbarch, regnum); + addr = ia64_register_addr (gdbarch, regnum); + size = register_size (gdbarch, regnum); gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0); buf = alloca (size); @@ -699,37 +706,42 @@ ia64_linux_fetch_register (int regnum) buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)addr, 0); if (errno != 0) error (_("Couldn't read register %s (#%d): %s."), - REGISTER_NAME (regnum), regnum, safe_strerror (errno)); + gdbarch_register_name (gdbarch, regnum), + regnum, safe_strerror (errno)); addr += sizeof (PTRACE_TYPE_RET); } - regcache_raw_supply (current_regcache, regnum, buf); + regcache_raw_supply (regcache, regnum, buf); } /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this for all registers. */ static void -ia64_linux_fetch_registers (int regnum) +ia64_linux_fetch_registers (struct target_ops *ops, + struct regcache *regcache, int regnum) { if (regnum == -1) - for (regnum = 0; regnum < NUM_REGS; regnum++) - ia64_linux_fetch_register (regnum); + for (regnum = 0; + regnum < gdbarch_num_regs (get_regcache_arch (regcache)); + regnum++) + ia64_linux_fetch_register (regcache, regnum); else - ia64_linux_fetch_register (regnum); + ia64_linux_fetch_register (regcache, regnum); } /* Store register REGNUM into the inferior. */ static void -ia64_linux_store_register (int regnum) +ia64_linux_store_register (const struct regcache *regcache, int regnum) { + struct gdbarch *gdbarch = get_regcache_arch (regcache); CORE_ADDR addr; size_t size; PTRACE_TYPE_RET *buf; int pid, i; - if (ia64_cannot_store_register (regnum)) + if (ia64_cannot_store_register (gdbarch, regnum)) return; /* Cater for systems like GNU/Linux, that implement threads as @@ -739,21 +751,22 @@ ia64_linux_store_register (int regnum) pid = ptid_get_pid (inferior_ptid); /* This isn't really an address, but ptrace thinks of it as one. */ - addr = ia64_register_addr (regnum); - size = register_size (current_gdbarch, regnum); + addr = ia64_register_addr (gdbarch, regnum); + size = register_size (gdbarch, regnum); gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0); buf = alloca (size); /* Write the register contents into the inferior a chunk at a time. */ - regcache_raw_collect (current_regcache, regnum, buf); + regcache_raw_collect (regcache, regnum, buf); for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++) { errno = 0; ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)addr, buf[i]); if (errno != 0) error (_("Couldn't write register %s (#%d): %s."), - REGISTER_NAME (regnum), regnum, safe_strerror (errno)); + gdbarch_register_name (gdbarch, regnum), + regnum, safe_strerror (errno)); addr += sizeof (PTRACE_TYPE_RET); } @@ -763,13 +776,16 @@ ia64_linux_store_register (int regnum) this for all registers. */ static void -ia64_linux_store_registers (int regnum) +ia64_linux_store_registers (struct target_ops *ops, + struct regcache *regcache, int regnum) { if (regnum == -1) - for (regnum = 0; regnum < NUM_REGS; regnum++) - ia64_linux_store_register (regnum); + for (regnum = 0; + regnum < gdbarch_num_regs (get_regcache_arch (regcache)); + regnum++) + ia64_linux_store_register (regcache, regnum); else - ia64_linux_store_register (regnum); + ia64_linux_store_register (regcache, regnum); } @@ -796,7 +812,7 @@ void _initialize_ia64_linux_nat (void); void _initialize_ia64_linux_nat (void) { - struct target_ops *t = linux_target (); + struct target_ops *t; /* Fill in the generic GNU/Linux methods. */ t = linux_target (); @@ -829,4 +845,5 @@ _initialize_ia64_linux_nat (void) /* Register the target. */ linux_nat_add_target (t); + linux_nat_set_new_thread (t, ia64_linux_new_thread); }