projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Reading signal handler frame in AIX
[deliverable/binutils-gdb.git] / gdb / sparc64-tdep.c
diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c
index dea8e4d4aeb9cb9340a92d49e97bf725779a60cd..b1ee6c1b57d079d005cb65da2f1e607009fc25b4 100644 (file)
--- a/gdb/sparc64-tdep.c
+++ b/gdb/sparc64-tdep.c
@@ -214,7 +214,7 @@ read_maps_entry (const char *line,
 static bool
 adi_available (void)
 {
-  pid_t pid = ptid_get_pid (inferior_ptid);
+  pid_t pid = inferior_ptid.pid ();
   sparc64_adi_info *proc = get_adi_info_proc (pid);
   CORE_ADDR value;
 
@@ -222,10 +222,10 @@ adi_available (void)
     return proc->stat.is_avail;
 
   proc->stat.checked_avail = true;
-  if (target_auxv_search (target_stack, AT_ADI_BLKSZ, &value) <= 0)
+  if (target_auxv_search (current_top_target (), AT_ADI_BLKSZ, &value) <= 0)
     return false;
   proc->stat.blksize = value;
-  target_auxv_search (target_stack, AT_ADI_NBITS, &value);
+  target_auxv_search (current_top_target (), AT_ADI_NBITS, &value);
   proc->stat.nbits = value;
   proc->stat.max_version = (1 << proc->stat.nbits) - 2;
   proc->stat.is_avail = true;
@@ -238,7 +238,7 @@ adi_available (void)
 static CORE_ADDR
 adi_normalize_address (CORE_ADDR addr)
 {
-  adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
+  adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
 
   if (ast.nbits)
     {
@@ -258,7 +258,7 @@ adi_normalize_address (CORE_ADDR addr)
 static CORE_ADDR
 adi_align_address (CORE_ADDR naddr)
 {
-  adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
+  adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
 
   return (naddr - (naddr % ast.blksize)) / ast.blksize;
 }
@@ -268,7 +268,7 @@ adi_align_address (CORE_ADDR naddr)
 static int
 adi_convert_byte_count (CORE_ADDR naddr, int nbytes, CORE_ADDR locl)
 {
-  adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
+  adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
 
   return ((naddr + nbytes + ast.blksize - 1) / ast.blksize) - locl;
 }
@@ -285,7 +285,7 @@ adi_convert_byte_count (CORE_ADDR naddr, int nbytes, CORE_ADDR locl)
 static int
 adi_tag_fd (void)
 {
-  pid_t pid = ptid_get_pid (inferior_ptid);
+  pid_t pid = inferior_ptid.pid ();
   sparc64_adi_info *proc = get_adi_info_proc (pid);
 
   if (proc->stat.tag_fd != 0)
@@ -309,7 +309,7 @@ adi_is_addr_mapped (CORE_ADDR vaddr, size_t cnt)
   char filename[MAX_PROC_NAME_SIZE];
   size_t i = 0;
 
-  pid_t pid = ptid_get_pid (inferior_ptid);
+  pid_t pid = inferior_ptid.pid ();
   snprintf (filename, sizeof filename, "/proc/%ld/adi/maps", (long) pid);
   gdb::unique_xmalloc_ptr<char> data
     = target_fileio_read_stralloc (NULL, filename);
@@ -349,7 +349,7 @@ adi_read_versions (CORE_ADDR vaddr, size_t size, gdb_byte *tags)
 
   if (!adi_is_addr_mapped (vaddr, size))
     {
-      adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
+      adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
       error(_("Address at %s is not in ADI maps"),
             paddress (target_gdbarch (), vaddr * ast.blksize));
     }
@@ -370,7 +370,7 @@ adi_write_versions (CORE_ADDR vaddr, size_t size, unsigned char *tags)
 
   if (!adi_is_addr_mapped (vaddr, size))
     {
-      adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
+      adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
       error(_("Address at %s is not in ADI maps"),
             paddress (target_gdbarch (), vaddr * ast.blksize));
     }
@@ -388,7 +388,7 @@ adi_print_versions (CORE_ADDR vaddr, size_t cnt, gdb_byte *tags)
   int v_idx = 0;
   const int maxelts = 8;  /* # of elements per line */
 
-  adi_stat_t adi_stat = get_adi_info (ptid_get_pid (inferior_ptid));
+  adi_stat_t adi_stat = get_adi_info (inferior_ptid.pid ());
 
   while (cnt > 0)
     {
@@ -449,7 +449,7 @@ do_assign (CORE_ADDR start, size_t bcnt, int version)
 
    Command syntax:
 
-     adi (examine|x)/count <addr> */
+     adi (examine|x)[/COUNT] [ADDR] */
 
 static void
 adi_examine_command (const char *args, int from_tty)
@@ -461,8 +461,6 @@ adi_examine_command (const char *args, int from_tty)
   if (!adi_available ())
     error (_("No ADI information"));
 
-  pid_t pid = ptid_get_pid (inferior_ptid);
-  sparc64_adi_info *proc = get_adi_info_proc (pid);
   int cnt = 1;
   const char *p = args;
   if (p && *p == '/')
@@ -475,7 +473,7 @@ adi_examine_command (const char *args, int from_tty)
   if (p != 0 && *p != 0)
     next_address = parse_and_eval_address (p);
   if (!cnt || !next_address)
-    error (_("Usage: adi examine|x[/count] <addr>"));
+    error (_("Usage: adi examine|x[/COUNT] [ADDR]"));
 
   do_examine (next_address, cnt);
 }
@@ -484,11 +482,14 @@ adi_examine_command (const char *args, int from_tty)
 
    Command syntax:
 
-     adi (assign|a)/count <addr> = <version>  */
+     adi (assign|a)[/COUNT] ADDR = VERSION  */
 
 static void
 adi_assign_command (const char *args, int from_tty)
 {
+  static const char *adi_usage
+    = N_("Usage: adi assign|a[/COUNT] ADDR = VERSION");
+
   /* make sure program is active and adi is available */
   if (!target_has_execution)
     error (_("ADI command requires a live process/thread"));
@@ -498,13 +499,13 @@ adi_assign_command (const char *args, int from_tty)
 
   const char *exp = args;
   if (exp == 0)
-    error_no_arg (_("Usage: adi assign|a[/count] <addr> = <version>"));
+    error_no_arg (_(adi_usage));
 
   char *q = (char *) strchr (exp, '=');
   if (q)
     *q++ = 0;
   else
-    error (_("Usage: adi assign|a[/count] <addr> = <version>"));
+    error ("%s", _(adi_usage));
 
   size_t cnt = 1;
   const char *p = args;
@@ -518,12 +519,12 @@ adi_assign_command (const char *args, int from_tty)
   if (p != 0 && *p != 0)
     next_address = parse_and_eval_address (p);
   else
-    error (_("Usage: adi assign|a[/count] <addr> = <version>"));
+    error ("%s", _(adi_usage));
 
   int version = 0;
   if (q != NULL)           /* parse version tag */
     {
-      adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
+      adi_stat_t ast = get_adi_info (inferior_ptid.pid ());
       version = parse_and_eval_long (q);
       if (version < 0 || version > ast.max_version)
         error (_("Invalid ADI version tag %d"), version);
@@ -1897,36 +1898,36 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
          psr = ((tstate & TSTATE_CWP) | PSR_S | ((tstate & TSTATE_ICC) >> 12)
                 | ((tstate & TSTATE_XCC) >> 20) | PSR_V8PLUS);
          store_unsigned_integer (buf, 4, byte_order, psr);
-         regcache_raw_supply (regcache, SPARC32_PSR_REGNUM, buf);
+         regcache->raw_supply (SPARC32_PSR_REGNUM, buf);
        }
 
       if (regnum == SPARC32_PC_REGNUM || regnum == -1)
-       regcache_raw_supply (regcache, SPARC32_PC_REGNUM,
-                            regs + gregmap->r_pc_offset + 4);
+       regcache->raw_supply (SPARC32_PC_REGNUM,
+                             regs + gregmap->r_pc_offset + 4);
 
       if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
-       regcache_raw_supply (regcache, SPARC32_NPC_REGNUM,
-                            regs + gregmap->r_npc_offset + 4);
+       regcache->raw_supply (SPARC32_NPC_REGNUM,
+                             regs + gregmap->r_npc_offset + 4);
 
       if (regnum == SPARC32_Y_REGNUM || regnum == -1)
        {
          int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size;
-         regcache_raw_supply (regcache, SPARC32_Y_REGNUM, regs + offset);
+         regcache->raw_supply (SPARC32_Y_REGNUM, regs + offset);
        }
     }
   else
     {
       if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
-       regcache_raw_supply (regcache, SPARC64_STATE_REGNUM,
-                            regs + gregmap->r_tstate_offset);
+       regcache->raw_supply (SPARC64_STATE_REGNUM,
+                             regs + gregmap->r_tstate_offset);
 
       if (regnum == SPARC64_PC_REGNUM || regnum == -1)
-       regcache_raw_supply (regcache, SPARC64_PC_REGNUM,
-                            regs + gregmap->r_pc_offset);
+       regcache->raw_supply (SPARC64_PC_REGNUM,
+                             regs + gregmap->r_pc_offset);
 
       if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
-       regcache_raw_supply (regcache, SPARC64_NPC_REGNUM,
-                            regs + gregmap->r_npc_offset);
+       regcache->raw_supply (SPARC64_NPC_REGNUM,
+                             regs + gregmap->r_npc_offset);
 
       if (regnum == SPARC64_Y_REGNUM || regnum == -1)
        {
@@ -1935,17 +1936,17 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
          memset (buf, 0, 8);
          memcpy (buf + 8 - gregmap->r_y_size,
                  regs + gregmap->r_y_offset, gregmap->r_y_size);
-         regcache_raw_supply (regcache, SPARC64_Y_REGNUM, buf);
+         regcache->raw_supply (SPARC64_Y_REGNUM, buf);
        }
 
       if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
          && gregmap->r_fprs_offset != -1)
-       regcache_raw_supply (regcache, SPARC64_FPRS_REGNUM,
-                            regs + gregmap->r_fprs_offset);
+       regcache->raw_supply (SPARC64_FPRS_REGNUM,
+                             regs + gregmap->r_fprs_offset);
     }
 
   if (regnum == SPARC_G0_REGNUM || regnum == -1)
-    regcache_raw_supply (regcache, SPARC_G0_REGNUM, &zero);
+    regcache->raw_supply (SPARC_G0_REGNUM, &zero);
 
   if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
     {
@@ -1957,7 +1958,7 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
       for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
        {
          if (regnum == i || regnum == -1)
-           regcache_raw_supply (regcache, i, regs + offset);
+           regcache->raw_supply (i, regs + offset);
          offset += 8;
        }
     }
@@ -1983,7 +1984,7 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
          for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
            {
              if (regnum == i || regnum == -1)
-               regcache_raw_supply (regcache, i, regs + offset);
+               regcache->raw_supply (i, regs + offset);
              offset += 8;
            }
        }
@@ -2010,7 +2011,7 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
          gdb_byte buf[8];
 
          tstate = extract_unsigned_integer (regs + offset, 8, byte_order);
-         regcache_raw_collect (regcache, SPARC32_PSR_REGNUM, buf);
+         regcache->raw_collect (SPARC32_PSR_REGNUM, buf);
          psr = extract_unsigned_integer (buf, 4, byte_order);
          tstate |= (psr & PSR_ICC) << 12;
          if ((psr & (PSR_VERS | PSR_IMPL)) == PSR_V8PLUS)
@@ -2020,46 +2021,46 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
        }
 
       if (regnum == SPARC32_PC_REGNUM || regnum == -1)
-       regcache_raw_collect (regcache, SPARC32_PC_REGNUM,
-                             regs + gregmap->r_pc_offset + 4);
+       regcache->raw_collect (SPARC32_PC_REGNUM,
+                              regs + gregmap->r_pc_offset + 4);
 
       if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
-       regcache_raw_collect (regcache, SPARC32_NPC_REGNUM,
-                             regs + gregmap->r_npc_offset + 4);
+       regcache->raw_collect (SPARC32_NPC_REGNUM,
+                              regs + gregmap->r_npc_offset + 4);
 
       if (regnum == SPARC32_Y_REGNUM || regnum == -1)
        {
          int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size;
-         regcache_raw_collect (regcache, SPARC32_Y_REGNUM, regs + offset);
+         regcache->raw_collect (SPARC32_Y_REGNUM, regs + offset);
        }
     }
   else
     {
       if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
-       regcache_raw_collect (regcache, SPARC64_STATE_REGNUM,
-                             regs + gregmap->r_tstate_offset);
+       regcache->raw_collect (SPARC64_STATE_REGNUM,
+                              regs + gregmap->r_tstate_offset);
 
       if (regnum == SPARC64_PC_REGNUM || regnum == -1)
-       regcache_raw_collect (regcache, SPARC64_PC_REGNUM,
-                             regs + gregmap->r_pc_offset);
+       regcache->raw_collect (SPARC64_PC_REGNUM,
+                              regs + gregmap->r_pc_offset);
 
       if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
-       regcache_raw_collect (regcache, SPARC64_NPC_REGNUM,
-                             regs + gregmap->r_npc_offset);
+       regcache->raw_collect (SPARC64_NPC_REGNUM,
+                              regs + gregmap->r_npc_offset);
 
       if (regnum == SPARC64_Y_REGNUM || regnum == -1)
        {
          gdb_byte buf[8];
 
-         regcache_raw_collect (regcache, SPARC64_Y_REGNUM, buf);
+         regcache->raw_collect (SPARC64_Y_REGNUM, buf);
          memcpy (regs + gregmap->r_y_offset,
                  buf + 8 - gregmap->r_y_size, gregmap->r_y_size);
        }
 
       if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
          && gregmap->r_fprs_offset != -1)
-       regcache_raw_collect (regcache, SPARC64_FPRS_REGNUM,
-                             regs + gregmap->r_fprs_offset);
+       regcache->raw_collect (SPARC64_FPRS_REGNUM,
+                              regs + gregmap->r_fprs_offset);
 
     }
 
@@ -2074,7 +2075,7 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
       for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
        {
          if (regnum == i || regnum == -1)
-           regcache_raw_collect (regcache, i, regs + offset);
+           regcache->raw_collect (i, regs + offset);
          offset += 8;
        }
     }
@@ -2093,7 +2094,7 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
          for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
            {
              if (regnum == i || regnum == -1)
-               regcache_raw_collect (regcache, i, regs + offset);
+               regcache->raw_collect (i, regs + offset);
              offset += 8;
            }
        }
@@ -2112,14 +2113,14 @@ sparc64_supply_fpregset (const struct sparc_fpregmap *fpregmap,
   for (i = 0; i < 32; i++)
     {
       if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
-       regcache_raw_supply (regcache, SPARC_F0_REGNUM + i,
-                            regs + fpregmap->r_f0_offset + (i * 4));
+       regcache->raw_supply (SPARC_F0_REGNUM + i,
+                             regs + fpregmap->r_f0_offset + (i * 4));
     }
 
   if (sparc32)
     {
       if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
-       regcache_raw_supply (regcache, SPARC32_FSR_REGNUM,
+       regcache->raw_supply (SPARC32_FSR_REGNUM,
                             regs + fpregmap->r_fsr_offset);
     }
   else
@@ -2127,14 +2128,14 @@ sparc64_supply_fpregset (const struct sparc_fpregmap *fpregmap,
       for (i = 0; i < 16; i++)
        {
          if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
-           regcache_raw_supply (regcache, SPARC64_F32_REGNUM + i,
-                                (regs + fpregmap->r_f0_offset
-                                 + (32 * 4) + (i * 8)));
+           regcache->raw_supply
+             (SPARC64_F32_REGNUM + i,
+              regs + fpregmap->r_f0_offset + (32 * 4) + (i * 8));
        }
 
       if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
-       regcache_raw_supply (regcache, SPARC64_FSR_REGNUM,
-                            regs + fpregmap->r_fsr_offset);
+       regcache->raw_supply (SPARC64_FSR_REGNUM,
+                             regs + fpregmap->r_fsr_offset);
     }
 }
 
@@ -2150,29 +2151,29 @@ sparc64_collect_fpregset (const struct sparc_fpregmap *fpregmap,
   for (i = 0; i < 32; i++)
     {
       if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
-       regcache_raw_collect (regcache, SPARC_F0_REGNUM + i,
-                             regs + fpregmap->r_f0_offset + (i * 4));
+       regcache->raw_collect (SPARC_F0_REGNUM + i,
+                              regs + fpregmap->r_f0_offset + (i * 4));
     }
 
   if (sparc32)
     {
       if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
-       regcache_raw_collect (regcache, SPARC32_FSR_REGNUM,
-                             regs + fpregmap->r_fsr_offset);
+       regcache->raw_collect (SPARC32_FSR_REGNUM,
+                              regs + fpregmap->r_fsr_offset);
     }
   else
     {
       for (i = 0; i < 16; i++)
        {
          if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
-           regcache_raw_collect (regcache, SPARC64_F32_REGNUM + i,
-                                 (regs + fpregmap->r_f0_offset
-                                  + (32 * 4) + (i * 8)));
+           regcache->raw_collect (SPARC64_F32_REGNUM + i,
+                                  (regs + fpregmap->r_f0_offset
+                                   + (32 * 4) + (i * 8)));
        }
 
       if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
-       regcache_raw_collect (regcache, SPARC64_FSR_REGNUM,
-                             regs + fpregmap->r_fsr_offset);
+       regcache->raw_collect (SPARC64_FSR_REGNUM,
+                              regs + fpregmap->r_fsr_offset);
     }
 }
 
GDB Binutils - Deliverables
This page took 0.047984 seconds and 4 git commands to generate.