X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fm32r-linux-nat.c;h=05f338809dd7a4124527ddea870f2589e1c947fc;hb=405e54e9944dcdcea88518f8d9bdbeff6752d78f;hp=a8c5031cf844ac724b1ccde029531f6d4343da80;hpb=e2e0b3e57f11bb2539724fc955af7e22380613c1;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/m32r-linux-nat.c b/gdb/m32r-linux-nat.c index a8c5031cf8..05f338809d 100644 --- a/gdb/m32r-linux-nat.c +++ b/gdb/m32r-linux-nat.c @@ -1,12 +1,13 @@ /* Native-dependent code for GNU/Linux m32r. - Copyright 2004 Free Software Foundation, Inc. + Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 + 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,15 +16,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 "inferior.h" #include "gdbcore.h" #include "regcache.h" #include "linux-nat.h" +#include "target.h" #include "gdb_assert.h" #include "gdb_string.h" @@ -56,8 +56,9 @@ static int regmap[] = { #define SPU_REGMAP 23 #define SPI_REGMAP 26 -/* Doee apply to the corresponding SET requests as well. */ -#define GETREGS_SUPPLIES(regno) (0 <= (regno) && (regno) <= M32R_LINUX_NUM_REGS) +/* Doee (??) apply to the corresponding SET requests as well. */ +#define GETREGS_SUPPLIES(regno) (0 <= (regno) \ + && (regno) <= M32R_LINUX_NUM_REGS) @@ -68,9 +69,9 @@ static int regmap[] = { in *GREGSETP. */ void -supply_gregset (elf_gregset_t * gregsetp) +supply_gregset (struct regcache *regcache, const elf_gregset_t * gregsetp) { - elf_greg_t *regp = (elf_greg_t *) gregsetp; + const elf_greg_t *regp = (const elf_greg_t *) gregsetp; int i; unsigned long psw, bbpsw; @@ -79,23 +80,27 @@ supply_gregset (elf_gregset_t * gregsetp) for (i = 0; i < M32R_LINUX_NUM_REGS; i++) { + elf_greg_t regval; + switch (i) { case PSW_REGNUM: - *(regp + regmap[i]) = - ((0x00c1 & bbpsw) << 8) | ((0xc100 & psw) >> 8); + regval = ((0x00c1 & bbpsw) << 8) | ((0xc100 & psw) >> 8); break; case CBR_REGNUM: - *(regp + regmap[i]) = ((psw >> 8) & 1); + regval = ((psw >> 8) & 1); + break; + default: + regval = *(regp + regmap[i]); break; } if (i != M32R_SP_REGNUM) - regcache_raw_supply (current_regcache, i, regp + regmap[i]); + regcache_raw_supply (regcache, i, ®val); else if (psw & 0x8000) - regcache_raw_supply (current_regcache, i, regp + SPU_REGMAP); + regcache_raw_supply (regcache, i, regp + SPU_REGMAP); else - regcache_raw_supply (current_regcache, i, regp + SPI_REGMAP); + regcache_raw_supply (regcache, i, regp + SPI_REGMAP); } } @@ -103,14 +108,14 @@ supply_gregset (elf_gregset_t * gregsetp) store their values in GDB's register array. */ static void -fetch_regs (int tid) +fetch_regs (struct regcache *regcache, int tid) { elf_gregset_t regs; if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0) perror_with_name (_("Couldn't get registers")); - supply_gregset (®s); + supply_gregset (regcache, (const elf_gregset_t *) ®s); } /* Fill register REGNO (if it is a general-purpose register) in @@ -118,7 +123,8 @@ fetch_regs (int tid) do this for all registers. */ void -fill_gregset (elf_gregset_t * gregsetp, int regno) +fill_gregset (const struct regcache *regcache, + elf_gregset_t * gregsetp, int regno) { elf_greg_t *regp = (elf_greg_t *) gregsetp; int i; @@ -139,11 +145,11 @@ fill_gregset (elf_gregset_t * gregsetp, int regno) continue; if (i != M32R_SP_REGNUM) - regcache_raw_collect (current_regcache, i, regp + regmap[i]); + regcache_raw_collect (regcache, i, regp + regmap[i]); else if (psw & 0x8000) - regcache_raw_collect (current_regcache, i, regp + SPU_REGMAP); + regcache_raw_collect (regcache, i, regp + SPU_REGMAP); else - regcache_raw_collect (current_regcache, i, regp + SPI_REGMAP); + regcache_raw_collect (regcache, i, regp + SPI_REGMAP); } } @@ -151,14 +157,14 @@ fill_gregset (elf_gregset_t * gregsetp, int regno) into the process/thread specified by TID. */ static void -store_regs (int tid, int regno) +store_regs (const struct regcache *regcache, int tid, int regno) { elf_gregset_t regs; if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0) perror_with_name (_("Couldn't get registers")); - fill_gregset (®s, regno); + fill_gregset (regcache, ®s, regno); if (ptrace (PTRACE_SETREGS, tid, 0, (int) ®s) < 0) perror_with_name (_("Couldn't write registers")); @@ -170,12 +176,13 @@ store_regs (int tid, int regno) Since M32R has no floating-point registers, these functions do nothing. */ void -supply_fpregset (gdb_fpregset_t *fpregs) +supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregs) { } void -fill_fpregset (gdb_fpregset_t *fpregs, int regno) +fill_fpregset (const struct regcache *regcache, + gdb_fpregset_t *fpregs, int regno) { } @@ -187,8 +194,9 @@ fill_fpregset (gdb_fpregset_t *fpregs, int regno) this for all registers (including the floating point and SSE registers). */ -void -fetch_inferior_registers (int regno) +static void +m32r_linux_fetch_inferior_registers (struct target_ops *ops, + struct regcache *regcache, int regno) { int tid; @@ -202,7 +210,7 @@ fetch_inferior_registers (int regno) results. */ if (regno == -1 || GETREGS_SUPPLIES (regno)) { - fetch_regs (tid); + fetch_regs (regcache, tid); return; } @@ -213,8 +221,9 @@ fetch_inferior_registers (int regno) /* Store register REGNO back into the child process. If REGNO is -1, do this for all registers (including the floating point and SSE registers). */ -void -store_inferior_registers (int regno) +static void +m32r_linux_store_inferior_registers (struct target_ops *ops, + struct regcache *regcache, int regno) { int tid; @@ -226,10 +235,28 @@ store_inferior_registers (int regno) transfers more registers in one system call. */ if (regno == -1 || GETREGS_SUPPLIES (regno)) { - store_regs (tid, regno); + store_regs (regcache, tid, regno); return; } internal_error (__FILE__, __LINE__, _("Got request to store bad register number %d."), regno); } + +void _initialize_m32r_linux_nat (void); + +void +_initialize_m32r_linux_nat (void) +{ + struct target_ops *t; + + /* Fill in the generic GNU/Linux methods. */ + t = linux_target (); + + /* Add our register access methods. */ + t->to_fetch_registers = m32r_linux_fetch_inferior_registers; + t->to_store_registers = m32r_linux_store_inferior_registers; + + /* Register the target. */ + linux_nat_add_target (t); +}