* gdbarch.sh (deprecated_register_size): Remove.

[deliverable/binutils-gdb.git] / gdb / xtensa-tdep.c

diff --git a/gdb/xtensa-tdep.c b/gdb/xtensa-tdep.c
index 77de43a339d34fdbae3acea02a41e7120a303501..f8024a7a73a97c757944fba5e7c58b46c498e4fb 100644 (file)
--- a/gdb/xtensa-tdep.c
+++ b/gdb/xtensa-tdep.c
@@ -209,7 +209,7 @@ xtensa_register_type (struct gdbarch *gdbarch, int regnum)
       || (regnum >= A0_BASE && regnum < A0_BASE + 16))
     return builtin_type_int;
 
-  if (regnum == PC_REGNUM || regnum == A1_REGNUM)
+  if (regnum == gdbarch_pc_regnum (current_gdbarch) || regnum == A1_REGNUM)
     return lookup_pointer_type (builtin_type_void);
 
   /* Return the stored type for all other registers.  */
@@ -314,7 +314,8 @@ xtensa_reg_to_regnum (int regnum)
    (Note: The size of masked registers is always less or equal 32 bits.)  */
 
 static void
-xtensa_register_write_masked (xtensa_register_t *reg, unsigned char *buffer)
+xtensa_register_write_masked (struct regcache *regcache,
+                             xtensa_register_t *reg, const gdb_byte *buffer)
 {
   unsigned int value[(MAX_REGISTER_SIZE + 3) / 4];
 
@@ -383,10 +384,12 @@ xtensa_register_write_masked (xtensa_register_t *reg, unsigned char *buffer)
       if (r >= 0 && size > 0)
        {
          /* Don't overwrite the unmasked areas.  */
+         ULONGEST old_val;
+         regcache_cooked_read_unsigned (regcache, r, &old_val);
          m = 0xffffffff >> (32 - size) << start;
          regval <<= start;
-         regval = (regval & m) | (read_register (r) & ~m);
-         write_register (r, regval);
+         regval = (regval & m) | (old_val & ~m);
+         regcache_cooked_write_unsigned (regcache, r, regval);
        }
     }
 }
@@ -396,7 +399,8 @@ xtensa_register_write_masked (xtensa_register_t *reg, unsigned char *buffer)
    register.  */
 
 static void
-xtensa_register_read_masked (xtensa_register_t *reg, unsigned char *buffer)
+xtensa_register_read_masked (struct regcache *regcache,
+                            xtensa_register_t *reg, gdb_byte *buffer)
 {
   unsigned int value[(MAX_REGISTER_SIZE + 3) / 4];
 
@@ -419,7 +423,15 @@ xtensa_register_read_masked (xtensa_register_t *reg, unsigned char *buffer)
   for (i = 0; i < mask->count; i++)
     {
       int r = mask->mask[i].reg_num;
-      regval = (r >= 0) ? read_register (r) : 0;
+      if (r >= 0)
+       {
+         ULONGEST val;
+         regcache_cooked_read_unsigned (regcache, r, &val);
+         regval = (unsigned int) val;
+       }
+      else
+       regval = 0;
+
       start = mask->mask[i].bit_start;
       size = mask->mask[i].bit_size;
 
@@ -541,7 +553,7 @@ xtensa_pseudo_register_read (struct gdbarch *gdbarch,
       /* We can always read mapped registers.  */
       else if (type == xtRegisterTypeMapped || type == xtRegisterTypeTieState)
         {
-         xtensa_register_read_masked (reg, (unsigned char *) buffer);
+         xtensa_register_read_masked (regcache, reg, buffer);
          return;
        }
 
@@ -629,7 +641,7 @@ xtensa_pseudo_register_write (struct gdbarch *gdbarch,
       /* We can always write mapped registers.  */
       else if (type == xtRegisterTypeMapped || type == xtRegisterTypeTieState)
         {
-         xtensa_register_write_masked (reg, (unsigned char *) buffer);
+         xtensa_register_write_masked (regcache, reg, buffer);
          return;
        }
 
@@ -736,10 +748,13 @@ xtensa_supply_gregset (const struct regset *regset,
 
   DEBUGTRACE ("xtensa_supply_gregset (..., regnum==%d, ...) \n", regnum);
 
-  if (regnum == PC_REGNUM || regnum == -1)
-    regcache_raw_supply (rc, PC_REGNUM, (char *) &regs->pc);
-  if (regnum == PS_REGNUM || regnum == -1)
-    regcache_raw_supply (rc, PS_REGNUM, (char *) &regs->ps);
+  if (regnum == gdbarch_pc_regnum (current_gdbarch) || regnum == -1)
+    regcache_raw_supply (rc,
+                        gdbarch_pc_regnum (current_gdbarch),
+                        (char *) &regs->pc);
+  if (regnum == gdbarch_ps_regnum (current_gdbarch) || regnum == -1)
+    regcache_raw_supply (rc, gdbarch_ps_regnum (current_gdbarch),
+                        (char *) &regs->ps);
   if (regnum == WB_REGNUM || regnum == -1)
     regcache_raw_supply (rc, WB_REGNUM, (char *) &regs->windowbase);
   if (regnum == WS_REGNUM || regnum == -1)
@@ -856,7 +871,7 @@ xtensa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 
   DEBUGTRACE ("xtensa_unwind_pc (next_frame = %p)\n", next_frame);
 
-  frame_unwind_register (next_frame, PC_REGNUM, buf);
+  frame_unwind_register (next_frame, gdbarch_pc_regnum (current_gdbarch), buf);
 
   DEBUGINFO ("[xtensa_unwind_pc] pc = 0x%08x\n", (unsigned int)
             extract_typed_address (buf, builtin_type_void_func_ptr));
@@ -906,14 +921,15 @@ xtensa_frame_cache (struct frame_info *next_frame, void **this_cache)
   /* Get windowbase, windowstart, ps, and pc.  */
   wb = frame_unwind_register_unsigned (next_frame, WB_REGNUM);
   ws = frame_unwind_register_unsigned (next_frame, WS_REGNUM);
-  ps = frame_unwind_register_unsigned (next_frame, PS_REGNUM);
-  pc = frame_unwind_register_unsigned (next_frame, PC_REGNUM);
+  ps = frame_unwind_register_unsigned (next_frame,
+                                      gdbarch_ps_regnum (current_gdbarch));
+  pc = frame_unwind_register_unsigned (next_frame,
+                                      gdbarch_pc_regnum (current_gdbarch));
 
   op1 = read_memory_integer (pc, 1);
-  if (XTENSA_IS_ENTRY (op1) || !windowing_enabled (read_register (PS_REGNUM)))
+  if (XTENSA_IS_ENTRY (op1) || !windowing_enabled (ps))
     {
-      int callinc = CALLINC (frame_unwind_register_unsigned (next_frame,
-                                                            PS_REGNUM));
+      int callinc = CALLINC (ps);
       ra = frame_unwind_register_unsigned (next_frame,
                                           A0_REGNUM + callinc * 4);
 
@@ -924,7 +940,7 @@ xtensa_frame_cache (struct frame_info *next_frame, void **this_cache)
       cache->callsize = 0;
       cache->wb = wb;
       cache->ws = ws;
-      cache->prev_sp = read_register (A1_REGNUM);
+      cache->prev_sp = frame_unwind_register_unsigned (next_frame, A1_REGNUM);
     }
   else
     {
@@ -987,7 +1003,7 @@ xtensa_frame_cache (struct frame_info *next_frame, void **this_cache)
 
          int regnum = AREG_NUMBER (A1_REGNUM, cache->wb);
 
-         cache->prev_sp = read_register (regnum);
+         cache->prev_sp = frame_unwind_register_unsigned (next_frame, regnum);
        }
     }
 
@@ -1051,9 +1067,9 @@ xtensa_frame_prev_register (struct frame_info *next_frame,
     }
   else if (regnum == WB_REGNUM)
     saved_reg = cache->wb;
-  else if (regnum == PC_REGNUM)
+  else if (regnum == gdbarch_pc_regnum (current_gdbarch))
     saved_reg = cache->pc;
-  else if (regnum == PS_REGNUM)
+  else if (regnum == gdbarch_ps_regnum (current_gdbarch))
     saved_reg = cache->ps;
   else
     done = 0;
@@ -1158,7 +1174,8 @@ xtensa_extract_return_value (struct type *type,
   gdb_assert(len > 0);
 
   /* First, we have to find the caller window in the register file.  */
-  regcache_raw_read_unsigned (regcache, PC_REGNUM, &pc);
+  regcache_raw_read_unsigned (regcache,
+                             gdbarch_pc_regnum (current_gdbarch), &pc);
   callsize = extract_call_winsize (pc);
 
   /* On Xtensa, we can return up to 4 words (or 2 when called by call12).  */
@@ -1201,7 +1218,8 @@ xtensa_store_return_value (struct type *type,
   DEBUGTRACE ("xtensa_store_return_value (...)\n");
 
   regcache_raw_read_unsigned (regcache, WB_REGNUM, &wb);
-  regcache_raw_read_unsigned (regcache, PC_REGNUM, &pc);
+  regcache_raw_read_unsigned (regcache,
+                             gdbarch_pc_regnum (current_gdbarch), &pc);
   callsize = extract_call_winsize (pc);
 
   if (len > (callsize > 8 ? 8 : 16))
@@ -1467,7 +1485,7 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch,
                /* ULONGEST v = extract_unsigned_integer (cp, REGISTER_SIZE);*/
                regcache_cooked_write (regcache, r, cp);
 
-               /* write_register (r, v); */
+               /* regcache_cooked_write_unsigned (regcache, r, v); */
                cp += REGISTER_SIZE;
                n -= REGISTER_SIZE;
                r++;
@@ -1481,10 +1499,12 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch,
      saved in the dummy frame, so we can savely overwrite A0 here.  */
 
   ra = (bp_addr & 0x3fffffff) | 0x40000000;
-  regcache_raw_read (regcache, PS_REGNUM, buf);
+  regcache_raw_read (regcache, gdbarch_ps_regnum (current_gdbarch), buf);
   ps = extract_unsigned_integer (buf, 4) & ~0x00030000;
   regcache_cooked_write_unsigned (regcache, A4_REGNUM, ra);
-  regcache_cooked_write_unsigned (regcache, PS_REGNUM, ps | 0x00010000);
+  regcache_cooked_write_unsigned (regcache,
+                                 gdbarch_ps_regnum (current_gdbarch),
+                                 ps | 0x00010000);
 
   /* Set new stack pointer and return it.  */
   regcache_cooked_write_unsigned (regcache, A1_REGNUM, sp);