* f-exp.y (yyparse): Add code to support exponentiation expression.

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

diff --git a/gdb/mipsv4-nat.c b/gdb/mipsv4-nat.c
index 702835555f906f7d2249aa581a8412f26fa8c850..bd48c6ebd0946f2158c043f2bf413180cda6c8a6 100644 (file)
--- a/gdb/mipsv4-nat.c
+++ b/gdb/mipsv4-nat.c
@@ -1,5 +1,5 @@
 /* Native support for MIPS running SVR4, for GDB.
-   Copyright 1994, 1995, 2001 Free Software Foundation, Inc.
+   Copyright 1994, 1995, 2000, 2001 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -45,54 +45,60 @@
 void
 supply_gregset (gregset_t *gregsetp)
 {
-  register int regi;
-  register greg_t *regp = &(*gregsetp)[0];
-  static char zerobuf[MAX_REGISTER_RAW_SIZE] =
-  {0};
+  int regi;
+  greg_t *regp = &(*gregsetp)[0];
+  char zerobuf[MAX_REGISTER_SIZE];
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   for (regi = 0; regi <= CXT_RA; regi++)
-    supply_register (regi, (char *) (regp + regi));
+    regcache_raw_supply (current_regcache, regi, (char *) (regp + regi));
 
-  supply_register (PC_REGNUM, (char *) (regp + CXT_EPC));
-  supply_register (HI_REGNUM, (char *) (regp + CXT_MDHI));
-  supply_register (LO_REGNUM, (char *) (regp + CXT_MDLO));
-  supply_register (CAUSE_REGNUM, (char *) (regp + CXT_CAUSE));
+  regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->pc,
+                      (char *) (regp + CXT_EPC));
+  regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->hi,
+                      (char *) (regp + CXT_MDHI));
+  regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->lo,
+                      (char *) (regp + CXT_MDLO));
+  regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->cause,
+                      (char *) (regp + CXT_CAUSE));
 
   /* Fill inaccessible registers with zero.  */
-  supply_register (PS_REGNUM, zerobuf);
-  supply_register (BADVADDR_REGNUM, zerobuf);
-  supply_register (FP_REGNUM, zerobuf);
-  supply_register (UNUSED_REGNUM, zerobuf);
-  for (regi = FIRST_EMBED_REGNUM; regi <= LAST_EMBED_REGNUM; regi++)
-    supply_register (regi, zerobuf);
+  regcache_raw_supply (current_regcache, MIPS_PS_REGNUM, zerobuf);
+  regcache_raw_supply (current_regcache,
+                      mips_regnum (current_gdbarch)->badvaddr,
+                      zerobuf);
+  regcache_raw_supply (current_regcache, DEPRECATED_FP_REGNUM, zerobuf);
+  regcache_raw_supply (current_regcache, MIPS_UNUSED_REGNUM, zerobuf);
+  for (regi = MIPS_FIRST_EMBED_REGNUM; regi <= MIPS_LAST_EMBED_REGNUM; regi++)
+    regcache_raw_supply (current_regcache, regi, zerobuf);
 }
 
 void
 fill_gregset (gregset_t *gregsetp, int regno)
 {
   int regi;
-  register greg_t *regp = &(*gregsetp)[0];
+  greg_t *regp = &(*gregsetp)[0];
 
   for (regi = 0; regi <= 32; regi++)
     if ((regno == -1) || (regno == regi))
-      *(regp + regi) = *(greg_t *) & registers[REGISTER_BYTE (regi)];
+      *(regp + regi) = *(greg_t *) & deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
 
-  if ((regno == -1) || (regno == PC_REGNUM))
-    *(regp + CXT_EPC) = *(greg_t *) & registers[REGISTER_BYTE (PC_REGNUM)];
+  if ((regno == -1) || (regno == mips_regnum (current_gdbarch)->pc))
+    *(regp + CXT_EPC) = *(greg_t *) & deprecated_registers[DEPRECATED_REGISTER_BYTE (mips_regnum (current_gdbarch)->pc)];
 
-  if ((regno == -1) || (regno == CAUSE_REGNUM))
-    *(regp + CXT_CAUSE) = *(greg_t *) & registers[REGISTER_BYTE (CAUSE_REGNUM)];
+  if ((regno == -1) || (regno == mips_regnum (current_gdbarch)->cause))
+    *(regp + CXT_CAUSE) = *(greg_t *) & deprecated_registers[DEPRECATED_REGISTER_BYTE (mips_regnum (current_gdbarch)->cause)];
 
-  if ((regno == -1) || (regno == HI_REGNUM))
-    *(regp + CXT_MDHI) = *(greg_t *) & registers[REGISTER_BYTE (HI_REGNUM)];
+  if ((regno == -1) || (regno == mips_regnum (current_gdbarch)->hi))
+    *(regp + CXT_MDHI) = *(greg_t *) & deprecated_registers[DEPRECATED_REGISTER_BYTE (mips_regnum (current_gdbarch)->hi)];
 
-  if ((regno == -1) || (regno == LO_REGNUM))
-    *(regp + CXT_MDLO) = *(greg_t *) & registers[REGISTER_BYTE (LO_REGNUM)];
+  if ((regno == -1) || (regno == mips_regnum (current_gdbarch)->lo))
+    *(regp + CXT_MDLO) = *(greg_t *) & deprecated_registers[DEPRECATED_REGISTER_BYTE (mips_regnum (current_gdbarch)->lo)];
 }
 
 /*
  * Now we do the same thing for floating-point registers.
- * We don't bother to condition on FP0_REGNUM since any
+ * We don't bother to condition on FP0 regnum since any
  * reasonable MIPS configuration has an R3010 in it.
  *
  * Again, see the comments in m68k-tdep.c.
@@ -101,18 +107,23 @@ fill_gregset (gregset_t *gregsetp, int regno)
 void
 supply_fpregset (fpregset_t *fpregsetp)
 {
-  register int regi;
-  static char zerobuf[MAX_REGISTER_RAW_SIZE] =
-  {0};
+  int regi;
+  char zerobuf[MAX_REGISTER_SIZE];
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   for (regi = 0; regi < 32; regi++)
-    supply_register (FP0_REGNUM + regi,
-                    (char *) &fpregsetp->fp_r.fp_regs[regi]);
-
-  supply_register (FCRCS_REGNUM, (char *) &fpregsetp->fp_csr);
-
-  /* FIXME: how can we supply FCRIR_REGNUM?  The ABI doesn't tell us. */
-  supply_register (FCRIR_REGNUM, zerobuf);
+    regcache_raw_supply (current_regcache,
+                        mips_regnum (current_gdbarch)->fp0 + regi,
+                        (char *) &fpregsetp->fp_r.fp_regs[regi]);
+
+  regcache_raw_supply (current_regcache,
+                      mips_regnum (current_gdbarch)->fp_control_status,
+                      (char *) &fpregsetp->fp_csr);
+
+  /* FIXME: how can we supply FCRIR?  The ABI doesn't tell us. */
+  regcache_raw_supply (current_regcache,
+                      mips_regnum (current_gdbarch)->fp_implementation_revision,
+                      zerobuf);
 }
 
 void
@@ -121,18 +132,20 @@ fill_fpregset (fpregset_t *fpregsetp, int regno)
   int regi;
   char *from, *to;
 
-  for (regi = FP0_REGNUM; regi < FP0_REGNUM + 32; regi++)
+  for (regi = mips_regnum (current_gdbarch)->fp0;
+       regi < mips_regnum (current_gdbarch)->fp0 + 32; regi++)
     {
       if ((regno == -1) || (regno == regi))
        {
-         from = (char *) &registers[REGISTER_BYTE (regi)];
-         to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]);
-         memcpy (to, from, REGISTER_RAW_SIZE (regi));
+         from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
+         to = (char *) &(fpregsetp->fp_r.fp_regs[regi - mips_regnum (current_gdbarch)->fp0]);
+         memcpy (to, from, register_size (current_gdbarch, regi));
        }
     }
 
-  if ((regno == -1) || (regno == FCRCS_REGNUM))
-    fpregsetp->fp_csr = *(unsigned *) &registers[REGISTER_BYTE (FCRCS_REGNUM)];
+  if ((regno == -1)
+      || (regno == mips_regnum (current_gdbarch)->fp_control_status))
+    fpregsetp->fp_csr = *(unsigned *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (mips_regnum (current_gdbarch)->fp_control_status)];
 }
 
 
@@ -148,13 +161,13 @@ get_longjmp_target (CORE_ADDR *pc)
   CORE_ADDR jb_addr;
 
   buf = alloca (TARGET_PTR_BIT / TARGET_CHAR_BIT);
-  jb_addr = read_register (A0_REGNUM);
+  jb_addr = read_register (MIPS_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;
 }