projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Adjust Value.location for lval_register
[deliverable/binutils-gdb.git] / gdb / sparc64-tdep.c
diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c
index 5d325606d4052a8af21fbfc1e837757e96a077e0..5e8f17deee878975025e5ed5e65d5d8a026c30e8 100644 (file)
--- a/gdb/sparc64-tdep.c
+++ b/gdb/sparc64-tdep.c
@@ -1,6 +1,6 @@
 /* Target-dependent code for UltraSPARC.
 
-   Copyright (C) 2003-2014 Free Software Foundation, Inc.
+   Copyright (C) 2003-2016 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -34,9 +34,6 @@
 #include "target.h"
 #include "value.h"
 
-#include "gdb_assert.h"
-#include <string.h>
-
 #include "sparc64-tdep.h"
 
 /* This file implements the SPARC 64-bit ABI as defined by the
@@ -893,7 +890,8 @@ sparc64_store_arguments (struct regcache *regcache, int nargs,
          /* Structure, Union or long double Complex arguments.  */
          gdb_assert (len <= 16);
          memset (buf, 0, sizeof (buf));
-         valbuf = memcpy (buf, valbuf, len);
+         memcpy (buf, valbuf, len);
+         valbuf = buf;
 
          if (element % 2 && sparc64_16_byte_align_p (type))
            element++;
@@ -1214,7 +1212,7 @@ sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
     (gdbarch, default_stabs_argument_has_addr);
 
   set_gdbarch_skip_prologue (gdbarch, sparc64_skip_prologue);
-  set_gdbarch_in_function_epilogue_p (gdbarch, sparc_in_function_epilogue_p);
+  set_gdbarch_stack_frame_destroyed_p (gdbarch, sparc_stack_frame_destroyed_p);
 
   /* Hook in the DWARF CFI frame unwinder.  */
   dwarf2_frame_set_init_reg (gdbarch, sparc64_dwarf2_frame_init_reg);
@@ -1240,14 +1238,14 @@ sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 #define PSR_XCC                0x000f0000
 
 void
-sparc64_supply_gregset (const struct sparc_gregset *gregset,
+sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
                        struct regcache *regcache,
                        int regnum, const void *gregs)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32);
-  const gdb_byte *regs = gregs;
+  const gdb_byte *regs = (const gdb_byte *) gregs;
   gdb_byte zero[8] = { 0 };
   int i;
 
@@ -1255,7 +1253,7 @@ sparc64_supply_gregset (const struct sparc_gregset *gregset,
     {
       if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
        {
-         int offset = gregset->r_tstate_offset;
+         int offset = gregmap->r_tstate_offset;
          ULONGEST tstate, psr;
          gdb_byte buf[4];
 
@@ -1268,15 +1266,15 @@ sparc64_supply_gregset (const struct sparc_gregset *gregset,
 
       if (regnum == SPARC32_PC_REGNUM || regnum == -1)
        regcache_raw_supply (regcache, SPARC32_PC_REGNUM,
-                            regs + gregset->r_pc_offset + 4);
+                            regs + gregmap->r_pc_offset + 4);
 
       if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
        regcache_raw_supply (regcache, SPARC32_NPC_REGNUM,
-                            regs + gregset->r_npc_offset + 4);
+                            regs + gregmap->r_npc_offset + 4);
 
       if (regnum == SPARC32_Y_REGNUM || regnum == -1)
        {
-         int offset = gregset->r_y_offset + 8 - gregset->r_y_size;
+         int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size;
          regcache_raw_supply (regcache, SPARC32_Y_REGNUM, regs + offset);
        }
     }
@@ -1284,30 +1282,30 @@ sparc64_supply_gregset (const struct sparc_gregset *gregset,
     {
       if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
        regcache_raw_supply (regcache, SPARC64_STATE_REGNUM,
-                            regs + gregset->r_tstate_offset);
+                            regs + gregmap->r_tstate_offset);
 
       if (regnum == SPARC64_PC_REGNUM || regnum == -1)
        regcache_raw_supply (regcache, SPARC64_PC_REGNUM,
-                            regs + gregset->r_pc_offset);
+                            regs + gregmap->r_pc_offset);
 
       if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
        regcache_raw_supply (regcache, SPARC64_NPC_REGNUM,
-                            regs + gregset->r_npc_offset);
+                            regs + gregmap->r_npc_offset);
 
       if (regnum == SPARC64_Y_REGNUM || regnum == -1)
        {
          gdb_byte buf[8];
 
          memset (buf, 0, 8);
-         memcpy (buf + 8 - gregset->r_y_size,
-                 regs + gregset->r_y_offset, gregset->r_y_size);
+         memcpy (buf + 8 - gregmap->r_y_size,
+                 regs + gregmap->r_y_offset, gregmap->r_y_size);
          regcache_raw_supply (regcache, SPARC64_Y_REGNUM, buf);
        }
 
       if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
-         && gregset->r_fprs_offset != -1)
+         && gregmap->r_fprs_offset != -1)
        regcache_raw_supply (regcache, SPARC64_FPRS_REGNUM,
-                            regs + gregset->r_fprs_offset);
+                            regs + gregmap->r_fprs_offset);
     }
 
   if (regnum == SPARC_G0_REGNUM || regnum == -1)
@@ -1315,7 +1313,7 @@ sparc64_supply_gregset (const struct sparc_gregset *gregset,
 
   if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
     {
-      int offset = gregset->r_g1_offset;
+      int offset = gregmap->r_g1_offset;
 
       if (sparc32)
        offset += 4;
@@ -1332,7 +1330,7 @@ sparc64_supply_gregset (const struct sparc_gregset *gregset,
     {
       /* Not all of the register set variants include Locals and
          Inputs.  For those that don't, we read them off the stack.  */
-      if (gregset->r_l0_offset == -1)
+      if (gregmap->r_l0_offset == -1)
        {
          ULONGEST sp;
 
@@ -1341,7 +1339,7 @@ sparc64_supply_gregset (const struct sparc_gregset *gregset,
        }
       else
        {
-         int offset = gregset->r_l0_offset;
+         int offset = gregmap->r_l0_offset;
 
          if (sparc32)
            offset += 4;
@@ -1357,21 +1355,21 @@ sparc64_supply_gregset (const struct sparc_gregset *gregset,
 }
 
 void
-sparc64_collect_gregset (const struct sparc_gregset *gregset,
+sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
                         const struct regcache *regcache,
                         int regnum, void *gregs)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32);
-  gdb_byte *regs = gregs;
+  gdb_byte *regs = (gdb_byte *) gregs;
   int i;
 
   if (sparc32)
     {
       if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
        {
-         int offset = gregset->r_tstate_offset;
+         int offset = gregmap->r_tstate_offset;
          ULONGEST tstate, psr;
          gdb_byte buf[8];
 
@@ -1387,15 +1385,15 @@ sparc64_collect_gregset (const struct sparc_gregset *gregset,
 
       if (regnum == SPARC32_PC_REGNUM || regnum == -1)
        regcache_raw_collect (regcache, SPARC32_PC_REGNUM,
-                             regs + gregset->r_pc_offset + 4);
+                             regs + gregmap->r_pc_offset + 4);
 
       if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
        regcache_raw_collect (regcache, SPARC32_NPC_REGNUM,
-                             regs + gregset->r_npc_offset + 4);
+                             regs + gregmap->r_npc_offset + 4);
 
       if (regnum == SPARC32_Y_REGNUM || regnum == -1)
        {
-         int offset = gregset->r_y_offset + 8 - gregset->r_y_size;
+         int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size;
          regcache_raw_collect (regcache, SPARC32_Y_REGNUM, regs + offset);
        }
     }
@@ -1403,35 +1401,35 @@ sparc64_collect_gregset (const struct sparc_gregset *gregset,
     {
       if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
        regcache_raw_collect (regcache, SPARC64_STATE_REGNUM,
-                             regs + gregset->r_tstate_offset);
+                             regs + gregmap->r_tstate_offset);
 
       if (regnum == SPARC64_PC_REGNUM || regnum == -1)
        regcache_raw_collect (regcache, SPARC64_PC_REGNUM,
-                             regs + gregset->r_pc_offset);
+                             regs + gregmap->r_pc_offset);
 
       if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
        regcache_raw_collect (regcache, SPARC64_NPC_REGNUM,
-                             regs + gregset->r_npc_offset);
+                             regs + gregmap->r_npc_offset);
 
       if (regnum == SPARC64_Y_REGNUM || regnum == -1)
        {
          gdb_byte buf[8];
 
          regcache_raw_collect (regcache, SPARC64_Y_REGNUM, buf);
-         memcpy (regs + gregset->r_y_offset,
-                 buf + 8 - gregset->r_y_size, gregset->r_y_size);
+         memcpy (regs + gregmap->r_y_offset,
+                 buf + 8 - gregmap->r_y_size, gregmap->r_y_size);
        }
 
       if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
-         && gregset->r_fprs_offset != -1)
+         && gregmap->r_fprs_offset != -1)
        regcache_raw_collect (regcache, SPARC64_FPRS_REGNUM,
-                             regs + gregset->r_fprs_offset);
+                             regs + gregmap->r_fprs_offset);
 
     }
 
   if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
     {
-      int offset = gregset->r_g1_offset;
+      int offset = gregmap->r_g1_offset;
 
       if (sparc32)
        offset += 4;
@@ -1449,9 +1447,9 @@ sparc64_collect_gregset (const struct sparc_gregset *gregset,
     {
       /* Not all of the register set variants include Locals and
          Inputs.  For those that don't, we read them off the stack.  */
-      if (gregset->r_l0_offset != -1)
+      if (gregmap->r_l0_offset != -1)
        {
-         int offset = gregset->r_l0_offset;
+         int offset = gregmap->r_l0_offset;
 
          if (sparc32)
            offset += 4;
@@ -1467,26 +1465,26 @@ sparc64_collect_gregset (const struct sparc_gregset *gregset,
 }
 
 void
-sparc64_supply_fpregset (const struct sparc_fpregset *fpregset,
+sparc64_supply_fpregset (const struct sparc_fpregmap *fpregmap,
                         struct regcache *regcache,
                         int regnum, const void *fpregs)
 {
   int sparc32 = (gdbarch_ptr_bit (get_regcache_arch (regcache)) == 32);
-  const gdb_byte *regs = fpregs;
+  const gdb_byte *regs = (const gdb_byte *) fpregs;
   int i;
 
   for (i = 0; i < 32; i++)
     {
       if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
        regcache_raw_supply (regcache, SPARC_F0_REGNUM + i,
-                            regs + fpregset->r_f0_offset + (i * 4));
+                            regs + fpregmap->r_f0_offset + (i * 4));
     }
 
   if (sparc32)
     {
       if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
        regcache_raw_supply (regcache, SPARC32_FSR_REGNUM,
-                            regs + fpregset->r_fsr_offset);
+                            regs + fpregmap->r_fsr_offset);
     }
   else
     {
@@ -1494,37 +1492,37 @@ sparc64_supply_fpregset (const struct sparc_fpregset *fpregset,
        {
          if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
            regcache_raw_supply (regcache, SPARC64_F32_REGNUM + i,
-                                (regs + fpregset->r_f0_offset
+                                (regs + fpregmap->r_f0_offset
                                  + (32 * 4) + (i * 8)));
        }
 
       if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
        regcache_raw_supply (regcache, SPARC64_FSR_REGNUM,
-                            regs + fpregset->r_fsr_offset);
+                            regs + fpregmap->r_fsr_offset);
     }
 }
 
 void
-sparc64_collect_fpregset (const struct sparc_fpregset *fpregset,
+sparc64_collect_fpregset (const struct sparc_fpregmap *fpregmap,
                          const struct regcache *regcache,
                          int regnum, void *fpregs)
 {
   int sparc32 = (gdbarch_ptr_bit (get_regcache_arch (regcache)) == 32);
-  gdb_byte *regs = fpregs;
+  gdb_byte *regs = (gdb_byte *) fpregs;
   int i;
 
   for (i = 0; i < 32; i++)
     {
       if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
        regcache_raw_collect (regcache, SPARC_F0_REGNUM + i,
-                             regs + fpregset->r_f0_offset + (i * 4));
+                             regs + fpregmap->r_f0_offset + (i * 4));
     }
 
   if (sparc32)
     {
       if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
        regcache_raw_collect (regcache, SPARC32_FSR_REGNUM,
-                             regs + fpregset->r_fsr_offset);
+                             regs + fpregmap->r_fsr_offset);
     }
   else
     {
@@ -1532,17 +1530,17 @@ sparc64_collect_fpregset (const struct sparc_fpregset *fpregset,
        {
          if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
            regcache_raw_collect (regcache, SPARC64_F32_REGNUM + i,
-                                 (regs + fpregset->r_f0_offset
+                                 (regs + fpregmap->r_f0_offset
                                   + (32 * 4) + (i * 8)));
        }
 
       if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
        regcache_raw_collect (regcache, SPARC64_FSR_REGNUM,
-                             regs + fpregset->r_fsr_offset);
+                             regs + fpregmap->r_fsr_offset);
     }
 }
 
-const struct sparc_fpregset sparc64_bsd_fpregset =
+const struct sparc_fpregmap sparc64_bsd_fpregmap =
 {
   0 * 8,                       /* %f0 */
   32 * 8,                      /* %fsr */
GDB Binutils - Deliverables
This page took 0.032715 seconds and 4 git commands to generate.