1 files changed, 161 insertions, 199 deletions

diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c
index 96910be..2f2160b 100644
--- a/gdb/sparc64-tdep.c
+++ b/gdb/sparc64-tdep.c
@@ -44,7 +44,7 @@
 /* Please use the sparc32_-prefix for 32-bit specific code, the
    sparc64_-prefix for 64-bit specific code and the sparc_-prefix for
    code can handle both.  */
-
+
 /* The M7 processor supports an Application Data Integrity (ADI) feature
    that detects invalid data accesses.  When software allocates memory and 
    enables ADI on the allocated memory, it chooses a 4-bit version number, 
@@ -63,23 +63,22 @@
 
    Note that 32-bit applications cannot use ADI. */
 
-
 #include <algorithm>
 #include "cli/cli-utils.h"
 #include "gdbcmd.h"
 #include "auxv.h"
 
-#define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/9999/adi/lstatus")
+#define MAX_PROC_NAME_SIZE sizeof ("/proc/99999/lwp/9999/adi/lstatus")
 
 /* ELF Auxiliary vectors */
 #ifndef AT_ADI_BLKSZ
-#define AT_ADI_BLKSZ    34
+#define AT_ADI_BLKSZ 34
 #endif
 #ifndef AT_ADI_NBITS
-#define AT_ADI_NBITS    35
+#define AT_ADI_NBITS 35
 #endif
 #ifndef AT_ADI_UEONADI
-#define AT_ADI_UEONADI  36
+#define AT_ADI_UEONADI 36
 #endif
 
 /* ADI command list.  */
@@ -107,7 +106,6 @@ struct adi_stat_t
 
   /* ADI is available.  */
   bool is_avail = false;
-
 };
 
 /* Per-process ADI stat info.  */
@@ -116,29 +114,27 @@ struct sparc64_adi_info
 {
   sparc64_adi_info (pid_t pid_)
     : pid (pid_)
-  {}
+  {
+  }
 
   /* The process identifier.  */
   pid_t pid;
 
   /* The ADI stat.  */
   adi_stat_t stat = {};
-
 };
 
 static std::forward_list<sparc64_adi_info> adi_proc_list;
 
-
 /* Get ADI info for process PID, creating one if it doesn't exist.  */
 
-static sparc64_adi_info * 
+static sparc64_adi_info *
 get_adi_info_proc (pid_t pid)
 {
   auto found = std::find_if (adi_proc_list.begin (), adi_proc_list.end (),
-			     [&pid] (const sparc64_adi_info &info)
-			     {
-			       return info.pid == pid;
-			     });
+			     [&pid] (const sparc64_adi_info &info) {
+    return info.pid == pid;
+  });
 
   if (found == adi_proc_list.end ())
     {
@@ -151,7 +147,7 @@ get_adi_info_proc (pid_t pid)
     }
 }
 
-static adi_stat_t 
+static adi_stat_t
 get_adi_info (pid_t pid)
 {
   sparc64_adi_info *proc;
@@ -168,14 +164,12 @@ sparc64_forget_process (pid_t pid)
 {
   fileio_error target_errno;
 
-  for (auto pit = adi_proc_list.before_begin (),
-	 it = std::next (pit);
-       it != adi_proc_list.end ();
-       )
+  for (auto pit = adi_proc_list.before_begin (), it = std::next (pit);
+       it != adi_proc_list.end ();)
     {
       if ((*it).pid == pid)
 	{
-	  if ((*it).stat.tag_fd > 0) 
+	  if ((*it).stat.tag_fd > 0)
 	    target_fileio_close ((*it).stat.tag_fd, &target_errno);
 	  adi_proc_list.erase_after (pit);
 	  break;
@@ -183,14 +177,12 @@ sparc64_forget_process (pid_t pid)
       else
 	pit = it++;
     }
-
 }
 
 /* Read attributes of a maps entry in /proc/[pid]/adi/maps.  */
 
 static void
-read_maps_entry (const char *line,
-	      ULONGEST *addr, ULONGEST *endaddr)
+read_maps_entry (const char *line, ULONGEST *addr, ULONGEST *endaddr)
 {
   const char *p = line;
 
@@ -284,9 +276,9 @@ adi_tag_fd (void)
     return proc->stat.tag_fd;
 
   char cl_name[MAX_PROC_NAME_SIZE];
-  snprintf (cl_name, sizeof(cl_name), "/proc/%ld/adi/tags", (long) pid);
+  snprintf (cl_name, sizeof (cl_name), "/proc/%ld/adi/tags", (long) pid);
   fileio_error target_errno;
-  proc->stat.tag_fd = target_fileio_open (NULL, cl_name, O_RDWR|O_EXCL, 
+  proc->stat.tag_fd = target_fileio_open (NULL, cl_name, O_RDWR | O_EXCL,
 					  false, 0, &target_errno);
   return proc->stat.tag_fd;
 }
@@ -309,8 +301,7 @@ adi_is_addr_mapped (CORE_ADDR vaddr, size_t cnt)
     {
       adi_stat_t adi_stat = get_adi_info (pid);
       char *saveptr;
-      for (char *line = strtok_r (data.get (), "\n", &saveptr);
-	   line;
+      for (char *line = strtok_r (data.get (), "\n", &saveptr); line;
 	   line = strtok_r (NULL, "\n", &saveptr))
 	{
 	  ULONGEST addr, endaddr;
@@ -324,9 +315,9 @@ adi_is_addr_mapped (CORE_ADDR vaddr, size_t cnt)
 		return true;
 	    }
 	}
-      }
+    }
   else
-    warning (_("unable to open /proc file '%s'"), filename);
+    warning (_ ("unable to open /proc file '%s'"), filename);
 
   return false;
 }
@@ -344,8 +335,8 @@ 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 (inferior_ptid.pid ());
-      error(_("Address at %s is not in ADI maps"),
-	    paddress (target_gdbarch (), vaddr * ast.blksize));
+      error (_ ("Address at %s is not in ADI maps"),
+	     paddress (target_gdbarch (), vaddr * ast.blksize));
     }
 
   fileio_error target_errno;
@@ -365,8 +356,8 @@ 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 (inferior_ptid.pid ());
-      error(_("Address at %s is not in ADI maps"),
-	    paddress (target_gdbarch (), vaddr * ast.blksize));
+      error (_ ("Address at %s is not in ADI maps"),
+	     paddress (target_gdbarch (), vaddr * ast.blksize));
     }
 
   fileio_error target_errno;
@@ -380,7 +371,7 @@ static void
 adi_print_versions (CORE_ADDR vaddr, size_t cnt, gdb_byte *tags)
 {
   int v_idx = 0;
-  const int maxelts = 8;  /* # of elements per line */
+  const int maxelts = 8; /* # of elements per line */
 
   adi_stat_t adi_stat = get_adi_info (inferior_ptid.pid ());
 
@@ -391,7 +382,7 @@ adi_print_versions (CORE_ADDR vaddr, size_t cnt, gdb_byte *tags)
 		  paddress (target_gdbarch (), vaddr * adi_stat.blksize));
       for (int i = maxelts; i > 0 && cnt > 0; i--, cnt--)
 	{
-	  if (tags[v_idx] == 0xff)    /* no version tag */
+	  if (tags[v_idx] == 0xff) /* no version tag */
 	    gdb_printf ("-");
 	  else
 	    gdb_printf ("%1X", tags[v_idx]);
@@ -414,9 +405,10 @@ do_examine (CORE_ADDR start, int bcnt)
   gdb::def_vector<gdb_byte> buf (cnt);
   int read_cnt = adi_read_versions (vstart, cnt, buf.data ());
   if (read_cnt == -1)
-    error (_("No ADI information"));
+    error (_ ("No ADI information"));
   else if (read_cnt < cnt)
-    error(_("No ADI information at %s"), paddress (target_gdbarch (), vaddr));
+    error (_ ("No ADI information at %s"),
+	   paddress (target_gdbarch (), vaddr));
 
   adi_print_versions (vstart, cnt, buf.data ());
 }
@@ -432,10 +424,10 @@ do_assign (CORE_ADDR start, size_t bcnt, int version)
   int set_cnt = adi_write_versions (vstart, cnt, buf.data ());
 
   if (set_cnt == -1)
-    error (_("No ADI information"));
+    error (_ ("No ADI information"));
   else if (set_cnt < cnt)
-    error(_("No ADI information at %s"), paddress (target_gdbarch (), vaddr));
-
+    error (_ ("No ADI information at %s"),
+	   paddress (target_gdbarch (), vaddr));
 }
 
 /* ADI examine version tag command.
@@ -449,10 +441,10 @@ adi_examine_command (const char *args, int from_tty)
 {
   /* make sure program is active and adi is available */
   if (!target_has_execution ())
-    error (_("ADI command requires a live process/thread"));
+    error (_ ("ADI command requires a live process/thread"));
 
   if (!adi_available ())
-    error (_("No ADI information"));
+    error (_ ("No ADI information"));
 
   int cnt = 1;
   const char *p = args;
@@ -466,7 +458,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);
 }
@@ -481,24 +473,24 @@ static void
 adi_assign_command (const char *args, int from_tty)
 {
   static const char *adi_usage
-    = N_("Usage: adi assign|a[/COUNT] ADDR = VERSION");
+    = 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"));
+    error (_ ("ADI command requires a live process/thread"));
 
   if (!adi_available ())
-    error (_("No ADI information"));
+    error (_ ("No ADI information"));
 
   const char *exp = args;
   if (exp == 0)
-    error_no_arg (_(adi_usage));
+    error_no_arg (_ (adi_usage));
 
   char *q = (char *) strchr (exp, '=');
   if (q)
     *q++ = 0;
   else
-    error ("%s", _(adi_usage));
+    error ("%s", _ (adi_usage));
 
   size_t cnt = 1;
   const char *p = args;
@@ -512,36 +504,35 @@ adi_assign_command (const char *args, int from_tty)
   if (p != 0 && *p != 0)
     next_address = parse_and_eval_address (p);
   else
-    error ("%s", _(adi_usage));
+    error ("%s", _ (adi_usage));
 
   int version = 0;
-  if (q != NULL)           /* parse version tag */
+  if (q != NULL) /* parse version tag */
     {
       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);
+	error (_ ("Invalid ADI version tag %d"), version);
     }
 
   do_assign (next_address, cnt, version);
 }
 
 void _initialize_sparc64_adi_tdep ();
+
 void
 _initialize_sparc64_adi_tdep ()
 {
   add_basic_prefix_cmd ("adi", class_support,
-			_("ADI version related commands."),
-			&sparc64adilist, 0, &cmdlist);
+			_ ("ADI version related commands."), &sparc64adilist,
+			0, &cmdlist);
   cmd_list_element *adi_examine_cmd
     = add_cmd ("examine", class_support, adi_examine_command,
-	       _("Examine ADI versions."), &sparc64adilist);
+	       _ ("Examine ADI versions."), &sparc64adilist);
   add_alias_cmd ("x", adi_examine_cmd, no_class, 1, &sparc64adilist);
   add_cmd ("assign", class_support, adi_assign_command,
-	   _("Assign ADI versions."), &sparc64adilist);
-
+	   _ ("Assign ADI versions."), &sparc64adilist);
 }
-
 
 /* The functions on this page are intended to be used to classify
    function arguments.  */
@@ -639,7 +630,6 @@ sparc64_structure_or_union_p (const struct type *type)
 
   return 0;
 }
-
 
 /* Construct types for ISA-specific registers.  */
 
@@ -748,36 +738,25 @@ sparc64_fprs_type (struct gdbarch *gdbarch)
   return tdep->sparc64_fprs_type;
 }
 
-
 /* Register information.  */
-#define SPARC64_FPU_REGISTERS                             \
-  "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",         \
-  "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",   \
-  "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", \
-  "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", \
-  "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46", \
-  "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62"
-#define SPARC64_CP0_REGISTERS                                             \
-  "pc", "npc",                                                            \
-  /* FIXME: Give "state" a name until we start using register groups.  */ \
-  "state",                                                                \
-  "fsr",                                                                  \
-  "fprs",                                                                 \
-  "y"
-
-static const char * const sparc64_fpu_register_names[] = {
-  SPARC64_FPU_REGISTERS
-};
-static const char * const sparc64_cp0_register_names[] = {
-  SPARC64_CP0_REGISTERS
-};
-
-static const char * const sparc64_register_names[] =
-{
-  SPARC_CORE_REGISTERS,
-  SPARC64_FPU_REGISTERS,
-  SPARC64_CP0_REGISTERS
-};
+#define SPARC64_FPU_REGISTERS                                               \
+  "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", \
+    "f12", "f13", "f14", "f15", "f16", "f17", "f18", "f19", "f20", "f21",   \
+    "f22", "f23", "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",   \
+    "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46", "f48", "f50",   \
+    "f52", "f54", "f56", "f58", "f60", "f62"
+#define SPARC64_CP0_REGISTERS                                                      \
+  "pc",                                                                            \
+    "npc", /* FIXME: Give "state" a name until we start using register groups.  */ \
+    "state", "fsr", "fprs", "y"
+
+static const char *const sparc64_fpu_register_names[]
+  = { SPARC64_FPU_REGISTERS };
+static const char *const sparc64_cp0_register_names[]
+  = { SPARC64_CP0_REGISTERS };
+
+static const char *const sparc64_register_names[]
+  = { SPARC_CORE_REGISTERS, SPARC64_FPU_REGISTERS, SPARC64_CP0_REGISTERS };
 
 /* Total number of registers.  */
 #define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_names)
@@ -785,17 +764,16 @@ static const char * const sparc64_register_names[] =
 /* We provide the aliases %d0..%d62 and %q0..%q60 for the floating
    registers as "psuedo" registers.  */
 
-static const char * const sparc64_pseudo_register_names[] =
-{
+static const char *const sparc64_pseudo_register_names[] = {
   "cwp", "pstate", "asi", "ccr",
 
-  "d0", "d2", "d4", "d6", "d8", "d10", "d12", "d14",
-  "d16", "d18", "d20", "d22", "d24", "d26", "d28", "d30",
-  "d32", "d34", "d36", "d38", "d40", "d42", "d44", "d46",
-  "d48", "d50", "d52", "d54", "d56", "d58", "d60", "d62",
+  "d0",	 "d2",	   "d4",  "d6",	 "d8",	"d10", "d12", "d14",
+  "d16", "d18",	   "d20", "d22", "d24", "d26", "d28", "d30",
+  "d32", "d34",	   "d36", "d38", "d40", "d42", "d44", "d46",
+  "d48", "d50",	   "d52", "d54", "d56", "d58", "d60", "d62",
 
-  "q0", "q4", "q8", "q12", "q16", "q20", "q24", "q28",
-  "q32", "q36", "q40", "q44", "q48", "q52", "q56", "q60",
+  "q0",	 "q4",	   "q8",  "q12", "q16", "q20", "q24", "q28",
+  "q32", "q36",	   "q40", "q44", "q48", "q52", "q56", "q60",
 };
 
 /* Total number of pseudo registers.  */
@@ -847,7 +825,7 @@ sparc64_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
   if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q60_REGNUM)
     return builtin_type (gdbarch)->builtin_long_double;
 
-  internal_error (_("sparc64_pseudo_register_type: bad register number %d"),
+  internal_error (_ ("sparc64_pseudo_register_type: bad register number %d"),
 		  regnum);
 }
 
@@ -888,13 +866,13 @@ sparc64_register_type (struct gdbarch *gdbarch, int regnum)
   if (regnum >= gdbarch_num_regs (gdbarch))
     return sparc64_pseudo_register_type (gdbarch, regnum);
 
-  internal_error (_("invalid regnum"));
+  internal_error (_ ("invalid regnum"));
 }
 
 static enum register_status
 sparc64_pseudo_register_read (struct gdbarch *gdbarch,
-			      readable_regcache *regcache,
-			      int regnum, gdb_byte *buf)
+			      readable_regcache *regcache, int regnum,
+			      gdb_byte *buf)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   enum register_status status;
@@ -938,10 +916,8 @@ sparc64_pseudo_register_read (struct gdbarch *gdbarch,
 
       return status;
     }
-  else if (regnum == SPARC64_CWP_REGNUM
-	   || regnum == SPARC64_PSTATE_REGNUM
-	   || regnum == SPARC64_ASI_REGNUM
-	   || regnum == SPARC64_CCR_REGNUM)
+  else if (regnum == SPARC64_CWP_REGNUM || regnum == SPARC64_PSTATE_REGNUM
+	   || regnum == SPARC64_ASI_REGNUM || regnum == SPARC64_CCR_REGNUM)
     {
       ULONGEST state;
 
@@ -972,8 +948,8 @@ sparc64_pseudo_register_read (struct gdbarch *gdbarch,
 
 static void
 sparc64_pseudo_register_write (struct gdbarch *gdbarch,
-			       struct regcache *regcache,
-			       int regnum, const gdb_byte *buf)
+			       struct regcache *regcache, int regnum,
+			       const gdb_byte *buf)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 
@@ -1004,10 +980,8 @@ sparc64_pseudo_register_write (struct gdbarch *gdbarch,
       regcache->raw_write (regnum, buf);
       regcache->raw_write (regnum + 1, buf + 8);
     }
-  else if (regnum == SPARC64_CWP_REGNUM
-	   || regnum == SPARC64_PSTATE_REGNUM
-	   || regnum == SPARC64_ASI_REGNUM
-	   || regnum == SPARC64_CCR_REGNUM)
+  else if (regnum == SPARC64_CWP_REGNUM || regnum == SPARC64_PSTATE_REGNUM
+	   || regnum == SPARC64_ASI_REGNUM || regnum == SPARC64_CCR_REGNUM)
     {
       ULONGEST state, bits;
 
@@ -1031,7 +1005,6 @@ sparc64_pseudo_register_write (struct gdbarch *gdbarch,
       regcache_raw_write_unsigned (regcache, SPARC64_STATE_REGNUM, state);
     }
 }
-
 
 /* Return PC of first real instruction of the function starting at
    START_PC.  */
@@ -1049,8 +1022,7 @@ sparc64_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
     {
       sal = find_pc_line (func_start, 0);
 
-      if (sal.end < func_end
-	  && start_pc <= sal.end)
+      if (sal.end < func_end && start_pc <= sal.end)
 	return sal.end;
     }
 
@@ -1070,8 +1042,8 @@ static void
 sparc64_frame_this_id (frame_info_ptr this_frame, void **this_cache,
 		       struct frame_id *this_id)
 {
-  struct sparc_frame_cache *cache =
-    sparc64_frame_cache (this_frame, this_cache);
+  struct sparc_frame_cache *cache
+    = sparc64_frame_cache (this_frame, this_cache);
 
   /* This marks the outermost frame.  */
   if (cache->base == 0)
@@ -1085,15 +1057,15 @@ sparc64_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
 			     int regnum)
 {
   struct gdbarch *gdbarch = get_frame_arch (this_frame);
-  struct sparc_frame_cache *cache =
-    sparc64_frame_cache (this_frame, this_cache);
+  struct sparc_frame_cache *cache
+    = sparc64_frame_cache (this_frame, this_cache);
 
   if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
     {
       CORE_ADDR pc = (regnum == SPARC64_NPC_REGNUM) ? 4 : 0;
 
-      regnum =
-	(cache->copied_regs_mask & 0x80) ? SPARC_I7_REGNUM : SPARC_O7_REGNUM;
+      regnum
+	= (cache->copied_regs_mask & 0x80) ? SPARC_I7_REGNUM : SPARC_O7_REGNUM;
       pc += get_frame_register_unsigned (this_frame, regnum) + 8;
       return frame_unwind_got_constant (this_frame, regnum, pc);
     }
@@ -1132,35 +1104,28 @@ sparc64_frame_prev_register (frame_info_ptr this_frame, void **this_cache,
   return frame_unwind_got_register (this_frame, regnum, regnum);
 }
 
-static const struct frame_unwind sparc64_frame_unwind =
-{
-  "sparc64 prologue",
-  NORMAL_FRAME,
-  default_frame_unwind_stop_reason,
-  sparc64_frame_this_id,
-  sparc64_frame_prev_register,
-  NULL,
-  default_frame_sniffer
-};
-
+static const struct frame_unwind sparc64_frame_unwind
+  = { "sparc64 prologue",
+      NORMAL_FRAME,
+      default_frame_unwind_stop_reason,
+      sparc64_frame_this_id,
+      sparc64_frame_prev_register,
+      NULL,
+      default_frame_sniffer };
 
 static CORE_ADDR
 sparc64_frame_base_address (frame_info_ptr this_frame, void **this_cache)
 {
-  struct sparc_frame_cache *cache =
-    sparc64_frame_cache (this_frame, this_cache);
+  struct sparc_frame_cache *cache
+    = sparc64_frame_cache (this_frame, this_cache);
 
   return cache->base;
 }
 
-static const struct frame_base sparc64_frame_base =
-{
-  &sparc64_frame_unwind,
-  sparc64_frame_base_address,
-  sparc64_frame_base_address,
-  sparc64_frame_base_address
-};
-
+static const struct frame_base sparc64_frame_base
+  = { &sparc64_frame_unwind, sparc64_frame_base_address,
+      sparc64_frame_base_address, sparc64_frame_base_address };
+
 /* Check whether TYPE must be 16-byte aligned.  */
 
 static int
@@ -1224,7 +1189,7 @@ sparc64_store_floating_fields (struct regcache *regcache, struct type *type,
 	regcache->cooked_write (regnum + n, valbuf + n * 4);
     }
   else if (sparc64_floating_p (type)
-      || (sparc64_complex_floating_p (type) && len <= 16))
+	   || (sparc64_complex_floating_p (type) && len <= 16))
     {
       int regnum;
 
@@ -1233,15 +1198,16 @@ sparc64_store_floating_fields (struct regcache *regcache, struct type *type,
 	  gdb_assert (bitpos == 0);
 	  gdb_assert ((element % 2) == 0);
 
-	  regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM + element / 2;
+	  regnum
+	    = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM + element / 2;
 	  regcache->cooked_write (regnum, valbuf);
 	}
       else if (len == 8)
 	{
 	  gdb_assert (bitpos == 0 || bitpos == 64);
 
-	  regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
-		   + element + bitpos / 64;
+	  regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + element
+		   + bitpos / 64;
 	  regcache->cooked_write (regnum, valbuf + (bitpos / 8));
 	}
       else
@@ -1262,8 +1228,8 @@ sparc64_store_floating_fields (struct regcache *regcache, struct type *type,
 	  struct type *subtype = check_typedef (type->field (i).type ());
 	  int subpos = bitpos + type->field (i).loc_bitpos ();
 
-	  sparc64_store_floating_fields (regcache, subtype, valbuf,
-					 element, subpos);
+	  sparc64_store_floating_fields (regcache, subtype, valbuf, element,
+					 subpos);
 	}
 
       /* GCC has an interesting bug.  If TYPE is a structure that has
@@ -1299,7 +1265,7 @@ sparc64_extract_floating_fields (struct regcache *regcache, struct type *type,
   if (type->code () == TYPE_CODE_ARRAY)
     {
       int len = type->length ();
-      int regnum =  SPARC_F0_REGNUM + bitpos / 32;
+      int regnum = SPARC_F0_REGNUM + bitpos / 32;
 
       valbuf += bitpos / 8;
       if (len < 4)
@@ -1321,15 +1287,16 @@ sparc64_extract_floating_fields (struct regcache *regcache, struct type *type,
 	{
 	  gdb_assert (bitpos == 0 || bitpos == 128);
 
-	  regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM
-		   + bitpos / 128;
+	  regnum
+	    = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM + bitpos / 128;
 	  regcache->cooked_read (regnum, valbuf + (bitpos / 8));
 	}
       else if (len == 8)
 	{
 	  gdb_assert (bitpos % 64 == 0 && bitpos >= 0 && bitpos < 256);
 
-	  regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + bitpos / 64;
+	  regnum
+	    = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + bitpos / 64;
 	  regcache->cooked_read (regnum, valbuf + (bitpos / 8));
 	}
       else
@@ -1446,8 +1413,8 @@ sparc64_store_arguments (struct regcache *regcache, int nargs,
 	     caller to an extended word according to the signed-ness
 	     of the argument type."  */
 	  if (len < 8)
-	    args[i] = value_cast (builtin_type (gdbarch)->builtin_int64,
-				  args[i]);
+	    args[i]
+	      = value_cast (builtin_type (gdbarch)->builtin_int64, args[i]);
 	  num_elements++;
 	}
     }
@@ -1513,7 +1480,8 @@ sparc64_store_arguments (struct regcache *regcache, int nargs,
 	  /* Float Complex or double Complex arguments.  */
 	  if (element < 16)
 	    {
-	      regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + element;
+	      regnum
+		= gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + element;
 
 	      if (len == 16)
 		{
@@ -1539,8 +1507,8 @@ sparc64_store_arguments (struct regcache *regcache, int nargs,
 	  else if (len == 8)
 	    {
 	      if (element < 16)
-		regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
-			 + element;
+		regnum
+		  = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + element;
 	    }
 	  else if (len == 4)
 	    {
@@ -1555,8 +1523,8 @@ sparc64_store_arguments (struct regcache *regcache, int nargs,
 	      valbuf = buf;
 	      len = 8;
 	      if (element < 16)
-		regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
-			 + element;
+		regnum
+		  = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + element;
 	    }
 	}
       else
@@ -1583,7 +1551,8 @@ sparc64_store_arguments (struct regcache *regcache, int nargs,
 		  regnum = SPARC_O0_REGNUM + element;
 		  regcache->cooked_write (regnum, valbuf);
 		}
-	      else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q8_REGNUM)
+	      else if (regnum >= SPARC64_Q0_REGNUM
+		       && regnum <= SPARC64_Q8_REGNUM)
 		{
 		  gdb_assert (element < 5);
 		  regnum = SPARC_O0_REGNUM + element;
@@ -1637,7 +1606,6 @@ sparc64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   return sp + BIAS;
 }
-
 
 /* Extract from an array REGBUF containing the (raw) register state, a
    function return value of TYPE, and copy that into VALBUF.  */
@@ -1759,7 +1727,6 @@ sparc64_return_value (struct gdbarch *gdbarch, struct value *function,
 
   return RETURN_VALUE_REGISTER_CONVENTION;
 }
-
 
 static void
 sparc64_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
@@ -1836,8 +1803,8 @@ sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 
   set_gdbarch_return_value (gdbarch, sparc64_return_value);
   set_gdbarch_return_value_as_value (gdbarch, default_gdbarch_return_value);
-  set_gdbarch_stabs_argument_has_addr
-    (gdbarch, default_stabs_argument_has_addr);
+  set_gdbarch_stabs_argument_has_addr (gdbarch,
+				       default_stabs_argument_has_addr);
 
   set_gdbarch_skip_prologue (gdbarch, sparc64_skip_prologue);
   set_gdbarch_stack_frame_destroyed_p (gdbarch, sparc_stack_frame_destroyed_p);
@@ -1852,29 +1819,28 @@ sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 
   set_gdbarch_addr_bits_remove (gdbarch, sparc64_addr_bits_remove);
 }
-
 
 /* Helper functions for dealing with register sets.  */
 
-#define TSTATE_CWP	0x000000000000001fULL
-#define TSTATE_ICC	0x0000000f00000000ULL
-#define TSTATE_XCC	0x000000f000000000ULL
+#define TSTATE_CWP 0x000000000000001fULL
+#define TSTATE_ICC 0x0000000f00000000ULL
+#define TSTATE_XCC 0x000000f000000000ULL
 
-#define PSR_S		0x00000080
+#define PSR_S 0x00000080
 #ifndef PSR_ICC
-#define PSR_ICC		0x00f00000
+#define PSR_ICC 0x00f00000
 #endif
-#define PSR_VERS	0x0f000000
+#define PSR_VERS 0x0f000000
 #ifndef PSR_IMPL
-#define PSR_IMPL	0xf0000000
+#define PSR_IMPL 0xf0000000
 #endif
-#define PSR_V8PLUS	0xff000000
-#define PSR_XCC		0x000f0000
+#define PSR_V8PLUS 0xff000000
+#define PSR_XCC 0x000f0000
 
 void
 sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
-			struct regcache *regcache,
-			int regnum, const void *gregs)
+			struct regcache *regcache, int regnum,
+			const void *gregs)
 {
   struct gdbarch *gdbarch = regcache->arch ();
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
@@ -1919,8 +1885,7 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
 			      regs + gregmap->r_tstate_offset);
 
       if (regnum == SPARC64_PC_REGNUM || regnum == -1)
-	regcache->raw_supply (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 (SPARC64_NPC_REGNUM,
@@ -1931,8 +1896,8 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
 	  gdb_byte buf[8];
 
 	  memset (buf, 0, 8);
-	  memcpy (buf + 8 - gregmap->r_y_size,
-		  regs + gregmap->r_y_offset, gregmap->r_y_size);
+	  memcpy (buf + 8 - gregmap->r_y_size, regs + gregmap->r_y_offset,
+		  gregmap->r_y_size);
 	  regcache->raw_supply (SPARC64_Y_REGNUM, buf);
 	}
 
@@ -1990,8 +1955,8 @@ sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
 
 void
 sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
-			 const struct regcache *regcache,
-			 int regnum, void *gregs)
+			 const struct regcache *regcache, int regnum,
+			 void *gregs)
 {
   struct gdbarch *gdbarch = regcache->arch ();
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
@@ -2038,8 +2003,7 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
 			       regs + gregmap->r_tstate_offset);
 
       if (regnum == SPARC64_PC_REGNUM || regnum == -1)
-	regcache->raw_collect (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 (SPARC64_NPC_REGNUM,
@@ -2050,15 +2014,14 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
 	  gdb_byte buf[8];
 
 	  regcache->raw_collect (SPARC64_Y_REGNUM, buf);
-	  memcpy (regs + gregmap->r_y_offset,
-		  buf + 8 - gregmap->r_y_size, gregmap->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)
 	  && gregmap->r_fprs_offset != -1)
 	regcache->raw_collect (SPARC64_FPRS_REGNUM,
 			       regs + gregmap->r_fprs_offset);
-
     }
 
   if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
@@ -2100,8 +2063,8 @@ sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
 
 void
 sparc64_supply_fpregset (const struct sparc_fpregmap *fpregmap,
-			 struct regcache *regcache,
-			 int regnum, const void *fpregs)
+			 struct regcache *regcache, int regnum,
+			 const void *fpregs)
 {
   int sparc32 = (gdbarch_ptr_bit (regcache->arch ()) == 32);
   const gdb_byte *regs = (const gdb_byte *) fpregs;
@@ -2118,16 +2081,16 @@ sparc64_supply_fpregset (const struct sparc_fpregmap *fpregmap,
     {
       if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
 	regcache->raw_supply (SPARC32_FSR_REGNUM,
-			     regs + fpregmap->r_fsr_offset);
+			      regs + fpregmap->r_fsr_offset);
     }
   else
     {
       for (i = 0; i < 16; i++)
 	{
 	  if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
-	    regcache->raw_supply
-	      (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)
@@ -2138,8 +2101,8 @@ sparc64_supply_fpregset (const struct sparc_fpregmap *fpregmap,
 
 void
 sparc64_collect_fpregset (const struct sparc_fpregmap *fpregmap,
-			  const struct regcache *regcache,
-			  int regnum, void *fpregs)
+			  const struct regcache *regcache, int regnum,
+			  void *fpregs)
 {
   int sparc32 = (gdbarch_ptr_bit (regcache->arch ()) == 32);
   gdb_byte *regs = (gdb_byte *) fpregs;
@@ -2164,8 +2127,8 @@ sparc64_collect_fpregset (const struct sparc_fpregmap *fpregmap,
 	{
 	  if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
 	    regcache->raw_collect (SPARC64_F32_REGNUM + i,
-				   (regs + fpregmap->r_f0_offset
-				    + (32 * 4) + (i * 8)));
+				   (regs + fpregmap->r_f0_offset + (32 * 4)
+				    + (i * 8)));
 	}
 
       if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
@@ -2174,8 +2137,7 @@ sparc64_collect_fpregset (const struct sparc_fpregmap *fpregmap,
     }
 }
 
-const struct sparc_fpregmap sparc64_bsd_fpregmap =
-{
-  0 * 8,			/* %f0 */
-  32 * 8,			/* %fsr */
+const struct sparc_fpregmap sparc64_bsd_fpregmap = {
+  0 * 8,  /* %f0 */
+  32 * 8, /* %fsr */
 };