* blockframe.c (inside_main_func): No longer use symbol_lookup()

[deliverable/binutils-gdb.git] / gdb / mips-nat.c

diff --git a/gdb/mips-nat.c b/gdb/mips-nat.c
index b9d20b700a7b94d41f7b761b566a3d2fec1e5755..4c359860ef2cd7024baf39fa0769e1db029c4cdf 100644 (file)
--- a/gdb/mips-nat.c
+++ b/gdb/mips-nat.c
@@ -1,5 +1,6 @@
 /* Low level DECstation interface to ptrace, for GDB when running native.
-   Copyright 1988, 1989, 1991, 1992, 1995 Free Software Foundation, Inc.
+   Copyright 1988, 1989, 1991, 1992, 1993, 1995, 1996, 1999, 2000, 2001
+   Free Software Foundation, Inc.
    Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
    and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
 
@@ -23,6 +24,7 @@
 #include "defs.h"
 #include "inferior.h"
 #include "gdbcore.h"
+#include "regcache.h"
 #include <sys/ptrace.h>
 #include <sys/types.h>
 #include <sys/param.h>
@@ -49,19 +51,19 @@
 /* Map gdb internal register number to ptrace ``address''.
    These ``addresses'' are defined in DECstation <sys/ptrace.h> */
 
-#define REGISTER_PTRACE_ADDR(regno) \
-   (regno < 32 ?               GPR_BASE + regno \
-  : regno == PC_REGNUM ?       PC      \
-  : regno == CAUSE_REGNUM ?    CAUSE   \
-  : regno == HI_REGNUM ?       MMHI    \
-  : regno == LO_REGNUM ?       MMLO    \
-  : regno == FCRCS_REGNUM ?    FPC_CSR \
-  : regno == FCRIR_REGNUM ?    FPC_EIR \
-  : regno >= FP0_REGNUM ?      FPR_BASE + (regno - FP0_REGNUM) \
-  : 0)
-
-static char zerobuf[MAX_REGISTER_RAW_SIZE] =
-{0};
+static int
+register_ptrace_addr (int regno)
+{
+  return (regno < 32 ? GPR_BASE + regno
+         : regno == PC_REGNUM ? PC
+         : regno == CAUSE_REGNUM ? CAUSE
+         : regno == HI_REGNUM ? MMHI
+         : regno == LO_REGNUM ? MMLO
+         : regno == FCRCS_REGNUM ? FPC_CSR
+         : regno == FCRIR_REGNUM ? FPC_EIR
+         : regno >= FP0_REGNUM ? FPR_BASE + (regno - FP0_REGNUM)
+         : 0);
+}
 
 static void fetch_core_registers (char *, unsigned, int, CORE_ADDR);
 
@@ -70,18 +72,20 @@ static void fetch_core_registers (char *, unsigned, int, CORE_ADDR);
 void
 fetch_inferior_registers (int regno)
 {
-  register unsigned int regaddr;
-  char buf[MAX_REGISTER_RAW_SIZE];
-  register int i;
+  unsigned int regaddr;
+  char buf[MAX_REGISTER_SIZE];
+  int i;
+  char zerobuf[MAX_REGISTER_SIZE];
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
-  registers_fetched ();
+  deprecated_registers_fetched ();
 
   for (regno = 1; regno < NUM_REGS; regno++)
     {
-      regaddr = REGISTER_PTRACE_ADDR (regno);
-      for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
+      regaddr = register_ptrace_addr (regno);
+      for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (int))
        {
-         *(int *) &buf[i] = ptrace (PT_READ_U, inferior_pid,
+         *(int *) &buf[i] = ptrace (PT_READ_U, PIDGET (inferior_ptid),
                                     (PTRACE_ARG3_TYPE) regaddr, 0);
          regaddr += sizeof (int);
        }
@@ -90,7 +94,7 @@ fetch_inferior_registers (int regno)
 
   supply_register (ZERO_REGNUM, zerobuf);
   /* Frame ptr reg must appear to be 0; it is faked by stack handling code. */
-  supply_register (FP_REGNUM, zerobuf);
+  supply_register (DEPRECATED_FP_REGNUM, zerobuf);
 }
 
 /* Store our register values back into the inferior.
@@ -100,19 +104,19 @@ fetch_inferior_registers (int regno)
 void
 store_inferior_registers (int regno)
 {
-  register unsigned int regaddr;
+  unsigned int regaddr;
   char buf[80];
 
   if (regno > 0)
     {
       if (regno == ZERO_REGNUM || regno == PS_REGNUM
          || regno == BADVADDR_REGNUM || regno == CAUSE_REGNUM
-         || regno == FCRIR_REGNUM || regno == FP_REGNUM
+         || regno == FCRIR_REGNUM || regno == DEPRECATED_FP_REGNUM
          || (regno >= FIRST_EMBED_REGNUM && regno <= LAST_EMBED_REGNUM))
        return;
-      regaddr = REGISTER_PTRACE_ADDR (regno);
+      regaddr = register_ptrace_addr (regno);
       errno = 0;
-      ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
+      ptrace (PT_WRITE_U, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) regaddr,
              read_register (regno));
       if (errno != 0)
        {
@@ -137,15 +141,16 @@ int
 get_longjmp_target (CORE_ADDR *pc)
 {
   CORE_ADDR jb_addr;
-  char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT];
+  char *buf;
 
+  buf = alloca (TARGET_PTR_BIT / TARGET_CHAR_BIT);
   jb_addr = read_register (A0_REGNUM);
 
   if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
                          TARGET_PTR_BIT / TARGET_CHAR_BIT))
     return 0;
 
-  *pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
+  *pc = extract_unsigned_integer (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
 
   return 1;
 }
@@ -167,10 +172,14 @@ static void
 fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
                      CORE_ADDR reg_addr)
 {
-  register int regno;
-  register unsigned int addr;
+  int regno;
+  unsigned int addr;
   int bad_reg = -1;
-  register reg_ptr = -reg_addr;        /* Original u.u_ar0 is -reg_addr. */
+  reg_ptr = -reg_addr; /* Original u.u_ar0 is -reg_addr. */
+
+  char zerobuf[MAX_REGISTER_SIZE];
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
+
 
   /* If u.u_ar0 was an absolute address in the core file, relativize it now,
      so we can use it as an offset into core_reg_sect.  When we're done,
@@ -204,7 +213,7 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
     }
   supply_register (ZERO_REGNUM, zerobuf);
   /* Frame ptr reg must appear to be 0; it is faked by stack handling code. */
-  supply_register (FP_REGNUM, zerobuf);
+  supply_register (DEPRECATED_FP_REGNUM, zerobuf);
 }
 
 /* Return the address in the core dump or inferior of register REGNO.