More Solaris procfs cleanup

This procfs.c (and friends) cleanup patch grew along a couple of lines:

* First I noticed that PR_MODEL_NATIVE is always defined now that
  Solaris 10 is the minimum supported version.

* Then there was a cleanup that I'd missed when removing support for
  !NEW_PROC_API, IRIX, and Tru64 UNIX: given that sysset_t is no longer
  dynamic, there's no need for the special sysset_t_alloc, but we can
  just use XNEW instead.

* Then I found one of those ARI warning mails on gdb-patches, discovered
  how to run it myself and fixed a large number of the warnings, among
  them all uses of sprintf.

  I had to silence the warnings in only 3 instances of the same issue,
  namely references to LDT in function names which are due to the
  libthread_db API.

* Even so, there were several formatting glitches, like braces around
  single statements in an if, which I chose to fix while I was at it.

The result has been tested on amd64-pc-solaris2.11 and
amd64-pc-solaris2.11.

	* proc-utils.h (PROC_CTL_WORD_TYPE): Remove.

	* procfs.c: Don't check for PR_MODEL_NATIVE definition.
	* sparc-sol2-nat.c: Likewise.  Remove Linux, __arch64__ references.
	* sol-thread.c (ps_pdmodel): Don't guard definition.

	* procfs.c: Fix formatting.

	* procfs.c (sysset_t_alloc): Remove.
	(create_procinfo): Use XNEW instead of sysset_t_alloc.
	(procfs_debug_inferior): Likewise.
	(procfs_set_exec_trap): Likewise.
	(proc_set_traced_sysentry): Don't allocate argp dynamically.
	(proc_set_traced_sysexit): Likewise.

	* procfs.c (create_procinfo): Use xsnprintf to fix ARI warning.
	(dead_procinfo): Likewise.
	(proc_warn): Likewise.
	(proc_error): Likewise.
	(proc_get_LDT_entry): Likewise.
	(do_attach): Likewise.
	(procfs_target::pid_to_str): Likewise.
	(iterate_over_mappings): Likewise.

	* procfs.c (create_procinfo): Fix ARI warning.
	(proc_get_status): Likewise.
	(proc_stop_process): Likewise.
	(proc_run_process): Likewise.
	(proc_kill): Likewise.
	(proc_get_LDT_entry): Likewise.
	(procfs_find_LDT_entry): Likewise.
	(proc_update_threads): Likewise.
	(proc_iterate_over_threads): Likewise.
	(do_attach): Likewise.
	(procfs_xfer_memory): Likewise.
	(invalidate_cache): Likewise.
	(procfs_target::resume): Likewise.
	(procfs_init_inferior): Likewise.
	(procfs_set_exec_trap): Likewise.
	(procfs_target::thread_alive): Likewise.
	(procfs_target::pid_to_exec_file): Likewise.
	(iterate_over_mappings): Likewise.
	(procfs_target::make_corefile_notes): Likewise.
	* sol-thread.c (sol_thread_target::thread_alive): Likewise.

	* procfs.c (procfs_find_LDT_entry): Silence ARI warning.
	(procfs_find_LDT_entry): Likewise.
	* sol-thread.c (ps_lgetLDT): Likewise.

1 files changed, 109 insertions, 132 deletions

diff --git a/gdb/procfs.c b/gdb/procfs.c
index 1fd55d3..6ffe569 100644
--- a/gdb/procfs.c
+++ b/gdb/procfs.c
@@ -141,7 +141,7 @@ public:
 
   bool info_proc (const char *, enum info_proc_what) override;
 
-#if defined(PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
+#if PR_MODEL_NATIVE == PR_MODEL_LP64
   int auxv_parse (gdb_byte **readptr,
 		  gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
     override;
@@ -163,7 +163,7 @@ public:
 
 static procfs_target the_procfs_target;
 
-#if defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
+#if PR_MODEL_NATIVE == PR_MODEL_LP64
 /* When GDB is built as 64-bit application on Solaris, the auxv data
    is presented in 64-bit format.  We need to provide a custom parser
    to handle that.  */
@@ -277,7 +277,6 @@ static void destroy_procinfo (procinfo *p);
 static void dead_procinfo (procinfo *p, const char *msg, int killp);
 static int open_procinfo_files (procinfo *p, int which);
 static void close_procinfo_files (procinfo *p);
-static sysset_t *sysset_t_alloc (procinfo *pi);
 
 static int iterate_over_mappings
   (procinfo *pi, find_memory_region_ftype child_func, void *data,
@@ -456,7 +455,8 @@ create_procinfo (int pid, int tid)
 {
   procinfo *pi, *parent = NULL;
 
-  if ((pi = find_procinfo (pid, tid)))
+  pi = find_procinfo (pid, tid);
+  if (pi != NULL)
     return pi;			/* Already exists, nothing to do.  */
 
   /* Find parent before doing malloc, to save having to cleanup.  */
@@ -470,19 +470,20 @@ create_procinfo (int pid, int tid)
   pi->pid = pid;
   pi->tid = tid;
 
-  pi->saved_entryset = sysset_t_alloc (pi);
-  pi->saved_exitset = sysset_t_alloc (pi);
+  pi->saved_entryset = XNEW (sysset_t);
+  pi->saved_exitset = XNEW (sysset_t);
 
   /* Chain into list.  */
   if (tid == 0)
     {
-      sprintf (pi->pathname, MAIN_PROC_NAME_FMT, pid);
+      xsnprintf (pi->pathname, sizeof (pi->pathname), MAIN_PROC_NAME_FMT, pid);
       pi->next = procinfo_list;
       procinfo_list = pi;
     }
   else
     {
-      sprintf (pi->pathname, "/proc/%d/lwp/%d", pid, tid);
+      xsnprintf (pi->pathname, sizeof (pi->pathname), "/proc/%d/lwp/%d",
+		 pid, tid);
       pi->next = parent->thread_list;
       parent->thread_list = pi;
     }
@@ -573,12 +574,10 @@ dead_procinfo (procinfo *pi, const char *msg, int kill_p)
   char procfile[80];
 
   if (pi->pathname)
-    {
-      print_sys_errmsg (pi->pathname, errno);
-    }
+    print_sys_errmsg (pi->pathname, errno);
   else
     {
-      sprintf (procfile, "process %d", pi->pid);
+      xsnprintf (procfile, sizeof (procfile), "process %d", pi->pid);
       print_sys_errmsg (procfile, errno);
     }
   if (kill_p == KILL)
@@ -588,14 +587,6 @@ dead_procinfo (procinfo *pi, const char *msg, int kill_p)
   error ("%s", msg);
 }
 
-/* Allocate and (partially) initialize a sysset_t struct.  */
-
-static sysset_t *
-sysset_t_alloc (procinfo *pi)
-{
-  return (sysset_t *) xmalloc (sizeof (sysset_t));
-}
-
 /* =================== END, STRUCT PROCINFO "MODULE" =================== */
 
 /* ===================  /proc  "MODULE" =================== */
@@ -623,14 +614,16 @@ static int proc_iterate_over_threads
 static void
 proc_warn (procinfo *pi, const char *func, int line)
 {
-  sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
+  xsnprintf (errmsg, sizeof (errmsg), "procfs: %s line %d, %s",
+	     func, line, pi->pathname);
   print_sys_errmsg (errmsg, errno);
 }
 
 static void
 proc_error (procinfo *pi, const char *func, int line)
 {
-  sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
+  xsnprintf (errmsg, sizeof (errmsg), "procfs: %s line %d, %s",
+	     func, line, pi->pathname);
   perror_with_name (errmsg);
 }
 
@@ -644,8 +637,7 @@ static int
 proc_get_status (procinfo *pi)
 {
   /* Status file descriptor is opened "lazily".  */
-  if (pi->status_fd == 0 &&
-      open_procinfo_files (pi, FD_STATUS) == 0)
+  if (pi->status_fd == 0 && open_procinfo_files (pi, FD_STATUS) == 0)
     {
       pi->status_valid = 0;
       return 0;
@@ -886,8 +878,7 @@ proc_stop_process (procinfo *pi)
   /* We might conceivably apply this operation to an LWP, and the
      LWP's ctl file descriptor might not be open.  */
 
-  if (pi->ctl_fd == 0 &&
-      open_procinfo_files (pi, FD_CTL) == 0)
+  if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0)
     return 0;
   else
     {
@@ -952,11 +943,8 @@ proc_run_process (procinfo *pi, int step, int signo)
   /* We will probably have to apply this operation to individual
      threads, so make sure the control file descriptor is open.  */
 
-  if (pi->ctl_fd == 0 &&
-      open_procinfo_files (pi, FD_CTL) == 0)
-    {
-      return 0;
-    }
+  if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0)
+    return 0;
 
   runflags    = PRCFAULT;	/* Always clear current fault.  */
   if (step)
@@ -1059,20 +1047,16 @@ proc_set_traced_sysentry (procinfo *pi, sysset_t *sysset)
   if (pi->tid != 0)
     pi = find_procinfo_or_die (pi->pid, 0);
 
-  struct gdb_proc_ctl_pcsentry {
+  struct {
     procfs_ctl_t cmd;
     /* Use char array to avoid alignment issues.  */
     char sysset[sizeof (sysset_t)];
-  } *argp;
-  int argp_size = sizeof (struct gdb_proc_ctl_pcsentry);
-
-  argp = (struct gdb_proc_ctl_pcsentry *) xmalloc (argp_size);
+  } arg;
 
-  argp->cmd = PCSENTRY;
-  memcpy (&argp->sysset, sysset, sizeof (sysset_t));
+  arg.cmd = PCSENTRY;
+  memcpy (&arg.sysset, sysset, sizeof (sysset_t));
 
-  win = (write (pi->ctl_fd, (char *) argp, argp_size) == argp_size);
-  xfree (argp);
+  win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
 
   /* The above operation renders the procinfo's cached pstatus
      obsolete.  */
@@ -1101,16 +1085,12 @@ proc_set_traced_sysexit (procinfo *pi, sysset_t *sysset)
     procfs_ctl_t cmd;
     /* Use char array to avoid alignment issues.  */
     char sysset[sizeof (sysset_t)];
-  } *argp;
-  int argp_size = sizeof (struct gdb_proc_ctl_pcsexit);
-
-  argp = (struct gdb_proc_ctl_pcsexit *) xmalloc (argp_size);
+  } arg;
 
-  argp->cmd = PCSEXIT;
-  memcpy (&argp->sysset, sysset, sizeof (sysset_t));
+  arg.cmd = PCSEXIT;
+  memcpy (&arg.sysset, sysset, sizeof (sysset_t));
 
-  win = (write (pi->ctl_fd, (char *) argp, argp_size) == argp_size);
-  xfree (argp);
+  win = (write (pi->ctl_fd, (char *) &arg, sizeof (arg)) == sizeof (arg));
 
   /* The above operation renders the procinfo's cached pstatus
      obsolete.  */
@@ -1445,9 +1425,7 @@ proc_set_gregs (procinfo *pi)
     return 0;			/* proc_get_regs has already warned.  */
 
   if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0)
-    {
-      return 0;
-    }
+    return 0;
   else
     {
       struct {
@@ -1481,9 +1459,7 @@ proc_set_fpregs (procinfo *pi)
     return 0;			/* proc_get_fpregs has already warned.  */
 
   if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0)
-    {
-      return 0;
-    }
+    return 0;
   else
     {
       struct {
@@ -1513,11 +1489,8 @@ proc_kill (procinfo *pi, int signo)
   /* We might conceivably apply this operation to an LWP, and the
      LWP's ctl file descriptor might not be open.  */
 
-  if (pi->ctl_fd == 0 &&
-      open_procinfo_files (pi, FD_CTL) == 0)
-    {
-      return 0;
-    }
+  if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0)
+    return 0;
   else
     {
       procfs_ctl_t cmd[2];
@@ -1595,7 +1568,7 @@ proc_set_watchpoint (procinfo *pi, CORE_ADDR addr, int len, int wflags)
    matching ssh struct (LDT entry).  */
 
 static struct ssd *
-proc_get_LDT_entry (procinfo *pi, int key)
+proc_get_LDT_entry (procinfo *pi, int key)	/* ARI: editCase function */
 {
   static struct ssd *ldt_entry = NULL;
   char pathname[MAX_PROC_NAME_SIZE];
@@ -1606,7 +1579,7 @@ proc_get_LDT_entry (procinfo *pi, int key)
     ldt_entry = XNEW (struct ssd);
 
   /* Open the file descriptor for the LDT table.  */
-  sprintf (pathname, "/proc/%d/ldt", pi->pid);
+  xsnprintf (pathname, sizeof (pathname), "/proc/%d/ldt", pi->pid);
   scoped_fd fd (open_with_retry (pathname, O_RDONLY));
   if (fd.get () < 0)
     {
@@ -1618,10 +1591,10 @@ proc_get_LDT_entry (procinfo *pi, int key)
   while (read (fd.get (), ldt_entry, sizeof (struct ssd))
 	 == sizeof (struct ssd))
     {
-      if (ldt_entry->sel == 0 &&
-	  ldt_entry->bo  == 0 &&
-	  ldt_entry->acc1 == 0 &&
-	  ldt_entry->acc2 == 0)
+      if (ldt_entry->sel == 0
+	  && ldt_entry->bo  == 0
+	  && ldt_entry->acc1 == 0
+	  && ldt_entry->acc2 == 0)
 	break;	/* end of table */
       /* If key matches, return this entry.  */
       if (ldt_entry->sel == key)
@@ -1634,21 +1607,23 @@ proc_get_LDT_entry (procinfo *pi, int key)
 /* Returns the pointer to the LDT entry of PTID.  */
 
 struct ssd *
-procfs_find_LDT_entry (ptid_t ptid)
+procfs_find_LDT_entry (ptid_t ptid)	/* ARI: editCase function */
 {
   gdb_gregset_t *gregs;
   int            key;
   procinfo      *pi;
 
   /* Find procinfo for the lwp.  */
-  if ((pi = find_procinfo (ptid.pid (), ptid.lwp ())) == NULL)
+  pi = find_procinfo (ptid.pid (), ptid.lwp ());
+  if (pi == NULL)
     {
       warning (_("procfs_find_LDT_entry: could not find procinfo for %d:%ld."),
 	       ptid.pid (), ptid.lwp ());
       return NULL;
     }
   /* get its general registers.  */
-  if ((gregs = proc_get_gregs (pi)) == NULL)
+  gregs = proc_get_gregs (pi);
+  if (gregs == NULL)
     {
       warning (_("procfs_find_LDT_entry: could not read gregs for %d:%ld."),
 	       ptid.pid (), ptid.lwp ());
@@ -1763,7 +1738,8 @@ proc_update_threads (procinfo *pi)
     if (direntry->d_name[0] != '.')		/* skip '.' and '..' */
       {
 	lwpid = atoi (&direntry->d_name[0]);
-	if ((thread = create_procinfo (pi->pid, lwpid)) == NULL)
+	thread = create_procinfo (pi->pid, lwpid);
+	if (thread == NULL)
 	  proc_error (pi, "update_threads, create_procinfo", __LINE__);
       }
   pi->threads_valid = 1;
@@ -1802,7 +1778,8 @@ proc_iterate_over_threads (procinfo *pi,
   for (thread = pi->thread_list; thread != NULL; thread = next)
     {
       next = thread->next;	/* In case thread is destroyed.  */
-      if ((retval = (*func) (pi, thread, ptr)) != 0)
+      retval = (*func) (pi, thread, ptr);
+      if (retval != 0)
 	break;
     }
 
@@ -1851,7 +1828,7 @@ procfs_debug_inferior (procinfo *pi)
 
 
   /* Register to trace the 'exit' system call (on entry).  */
-  traced_syscall_entries = sysset_t_alloc (pi);
+  traced_syscall_entries = XNEW (sysset_t);
   premptyset (traced_syscall_entries);
   praddset (traced_syscall_entries, SYS_exit);
   praddset (traced_syscall_entries, SYS_lwp_exit);
@@ -1867,7 +1844,7 @@ procfs_debug_inferior (procinfo *pi)
      names.  On the SGI, for example, there is no SYS_exec, but there
      *is* a SYS_execv.  So, we try to account for that.  */
 
-  traced_syscall_exits = sysset_t_alloc (pi);
+  traced_syscall_exits = XNEW (sysset_t);
   premptyset (traced_syscall_exits);
 #ifdef SYS_exec
   praddset (traced_syscall_exits, SYS_exec);
@@ -1946,14 +1923,16 @@ do_attach (ptid_t ptid)
   int fail;
   int lwpid;
 
-  if ((pi = create_procinfo (ptid.pid (), 0)) == NULL)
+  pi = create_procinfo (ptid.pid (), 0);
+  if (pi == NULL)
     perror (_("procfs: out of memory in 'attach'"));
 
   if (!open_procinfo_files (pi, FD_CTL))
     {
       fprintf_filtered (gdb_stderr, "procfs:%d -- ", __LINE__);
-      sprintf (errmsg, "do_attach: couldn't open /proc file for process %d",
-	       ptid.pid ());
+      xsnprintf (errmsg, sizeof (errmsg),
+		 "do_attach: couldn't open /proc file for process %d",
+		 ptid.pid ());
       dead_procinfo (pi, errmsg, NOKILL);
     }
 
@@ -1989,7 +1968,8 @@ do_attach (ptid_t ptid)
   if (!proc_get_held_signals    (pi, &pi->saved_sighold))
     dead_procinfo (pi, "do_attach: couldn't save held signals.", NOKILL);
 
-  if ((fail = procfs_debug_inferior (pi)) != 0)
+  fail = procfs_debug_inferior (pi);
+  if (fail != 0)
     dead_procinfo (pi, "do_attach: failed in procfs_debug_inferior", NOKILL);
 
   inf = current_inferior ();
@@ -2232,8 +2212,8 @@ wait_again:
 	pi->status_valid = 0;	/* re-read again, IMMEDIATELY...  */
 #endif
       /* If child is not stopped, wait for it to stop.  */
-      if (!(proc_flags (pi) & (PR_STOPPED | PR_ISTOP)) &&
-	  !proc_wait_for_stop (pi))
+      if (!(proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
+	  && !proc_wait_for_stop (pi))
 	{
 	  /* wait_for_stop failed: has the child terminated?  */
 	  if (errno == ENOENT)
@@ -2357,8 +2337,10 @@ wait_again:
 
 		    long i, nsysargs, *sysargs;
 
-		    if ((nsysargs = proc_nsysarg (pi)) > 0 &&
-			(sysargs  = proc_sysargs (pi)) != NULL)
+		    nsysargs = proc_nsysarg (pi);
+		    sysargs  = proc_sysargs (pi);
+
+		    if (nsysargs > 0 && sysargs != NULL)
 		      {
 			printf_filtered (_("%ld syscall arguments:\n"),
 					 nsysargs);
@@ -2441,8 +2423,10 @@ wait_again:
 
 		    long i, nsysargs, *sysargs;
 
-		    if ((nsysargs = proc_nsysarg (pi)) > 0 &&
-			(sysargs  = proc_sysargs (pi)) != NULL)
+		    nsysargs = proc_nsysarg (pi);
+		    sysargs = proc_sysargs (pi);
+
+		    if (nsysargs > 0 && sysargs != NULL)
 		      {
 			printf_filtered (_("%ld syscall arguments:\n"),
 					 nsysargs);
@@ -2530,9 +2514,9 @@ wait_again:
 	      }
 	      /* Got this far without error: If retval isn't in the
 		 threads database, add it.  */
-	      if (retval.pid () > 0 &&
-		  retval != inferior_ptid &&
-		  !in_thread_list (retval))
+	      if (retval.pid () > 0
+		  && retval != inferior_ptid
+		  && !in_thread_list (retval))
 		{
 		  /* We have a new thread.  We need to add it both to
 		     GDB's list and to our own.  If we don't create a
@@ -2598,8 +2582,7 @@ procfs_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
 
   /* Find procinfo for main process.  */
   pi = find_procinfo_or_die (inferior_ptid.pid (), 0);
-  if (pi->as_fd == 0 &&
-      open_procinfo_files (pi, FD_AS) == 0)
+  if (pi->as_fd == 0 && open_procinfo_files (pi, FD_AS) == 0)
     {
       proc_warn (pi, "xfer_memory, open_proc_files", __LINE__);
       return TARGET_XFER_E_IO;
@@ -2647,15 +2630,13 @@ invalidate_cache (procinfo *parent, procinfo *pi, void *ptr)
 
 #if 0
   if (pi->gregs_dirty)
-    if (parent == NULL ||
-	proc_get_current_thread (parent) != pi->tid)
+    if (parent == NULL || proc_get_current_thread (parent) != pi->tid)
       if (!proc_set_gregs (pi))	/* flush gregs cache */
 	proc_warn (pi, "target_resume, set_gregs",
 		   __LINE__);
   if (gdbarch_fp0_regnum (target_gdbarch ()) >= 0)
     if (pi->fpregs_dirty)
-      if (parent == NULL ||
-	  proc_get_current_thread (parent) != pi->tid)
+      if (parent == NULL || proc_get_current_thread (parent) != pi->tid)
 	if (!proc_set_fpregs (pi))	/* flush fpregs cache */
 	  proc_warn (pi, "target_resume, set_fpregs",
 		     __LINE__);
@@ -2740,8 +2721,7 @@ procfs_target::resume (ptid_t ptid, int step, enum gdb_signal signo)
   errno = 0;
 
   /* Convert signal to host numbering.  */
-  if (signo == 0 ||
-      (signo == GDB_SIGNAL_STOP && pi->ignore_next_sigstop))
+  if (signo == 0 || (signo == GDB_SIGNAL_STOP && pi->ignore_next_sigstop))
     native_signo = 0;
   else
     native_signo = gdb_signal_to_host (signo);
@@ -2906,7 +2886,8 @@ procfs_init_inferior (struct target_ops *ops, int pid)
   if (!target_is_pushed (ops))
     push_target (ops);
 
-  if ((pi = create_procinfo (pid, 0)) == NULL)
+  pi = create_procinfo (pid, 0);
+  if (pi == NULL)
     perror (_("procfs: out of memory in 'init_inferior'"));
 
   if (!open_procinfo_files (pi, FD_CTL))
@@ -2925,8 +2906,7 @@ procfs_init_inferior (struct target_ops *ops, int pid)
     */
 
   /* If not stopped yet, wait for it to stop.  */
-  if (!(proc_flags (pi) & PR_STOPPED) &&
-      !(proc_wait_for_stop (pi)))
+  if (!(proc_flags (pi) & PR_STOPPED) && !(proc_wait_for_stop (pi)))
     dead_procinfo (pi, "init_inferior: wait_for_stop failed", KILL);
 
   /* Save some of the /proc state to be restored if we detach.  */
@@ -2943,7 +2923,8 @@ procfs_init_inferior (struct target_ops *ops, int pid)
   if (!proc_get_traced_sysexit  (pi, pi->saved_exitset))
     proc_error (pi, "init_inferior, get_traced_sysexit", __LINE__);
 
-  if ((fail = procfs_debug_inferior (pi)) != 0)
+  fail = procfs_debug_inferior (pi);
+  if (fail != 0)
     proc_error (pi, "init_inferior (procfs_debug_inferior)", fail);
 
   /* FIXME: logically, we should really be turning OFF run-on-last-close,
@@ -2988,7 +2969,8 @@ procfs_set_exec_trap (void)
   procinfo *pi;
   sysset_t *exitset;
 
-  if ((pi = create_procinfo (getpid (), 0)) == NULL)
+  pi = create_procinfo (getpid (), 0);
+  if (pi == NULL)
     perror_with_name (_("procfs: create_procinfo failed in child."));
 
   if (open_procinfo_files (pi, FD_CTL) == 0)
@@ -3006,7 +2988,7 @@ procfs_set_exec_trap (void)
      names.  On the SGI, for example, there is no SYS_exec, but there
      *is* a SYS_execv.  So, we try to account for that.  */
 
-  exitset = sysset_t_alloc (pi);
+  exitset = XNEW (sysset_t);
   premptyset (exitset);
 #ifdef SYS_exec
   praddset (exitset, SYS_exec);
@@ -3185,7 +3167,8 @@ procfs_target::thread_alive (ptid_t ptid)
   proc    = ptid.pid ();
   thread  = ptid.lwp ();
   /* If I don't know it, it ain't alive!  */
-  if ((pi = find_procinfo (proc, thread)) == NULL)
+  pi = find_procinfo (proc, thread);
+  if (pi == NULL)
     return false;
 
   /* If I can't get its status, it ain't alive!
@@ -3209,9 +3192,9 @@ procfs_target::pid_to_str (ptid_t ptid)
   static char buf[80];
 
   if (ptid.lwp () == 0)
-    sprintf (buf, "process %d", ptid.pid ());
+    xsnprintf (buf, sizeof (buf), "process %d", ptid.pid ());
   else
-    sprintf (buf, "LWP %ld", ptid.lwp ());
+    xsnprintf (buf, sizeof (buf), "LWP %ld", ptid.lwp ());
 
   return buf;
 }
@@ -3226,7 +3209,7 @@ procfs_target::pid_to_exec_file (int pid)
   char name[PATH_MAX];
 
   /* Solaris 11 introduced /proc/<proc-id>/execname.  */
-  xsnprintf (name, PATH_MAX, "/proc/%d/execname", pid);
+  xsnprintf (name, sizeof (name), "/proc/%d/execname", pid);
   scoped_fd fd (gdb_open_cloexec (name, O_RDONLY, 0));
   if (fd.get () < 0 || read (fd.get (), buf, PATH_MAX - 1) < 0)
     {
@@ -3234,7 +3217,7 @@ procfs_target::pid_to_exec_file (int pid)
 	 Solaris 10.  */
       ssize_t len;
 
-      xsnprintf (name, PATH_MAX, "/proc/%d/path/a.out", pid);
+      xsnprintf (name, sizeof (name), "/proc/%d/path/a.out", pid);
       len = readlink (name, buf, PATH_MAX - 1);
       if (len <= 0)
 	strcpy (buf, name);
@@ -3335,13 +3318,9 @@ procfs_target::stopped_by_watchpoint ()
   pi = find_procinfo_or_die (inferior_ptid.pid (), 0);
 
   if (proc_flags (pi) & (PR_STOPPED | PR_ISTOP))
-    {
-      if (proc_why (pi) == PR_FAULTED)
-	{
-	  if (proc_what (pi) == FLTWATCH)
-	    return true;
-	}
-    }
+    if (proc_why (pi) == PR_FAULTED)
+      if (proc_what (pi) == FLTWATCH)
+	return true;
   return false;
 }
 
@@ -3367,20 +3346,16 @@ procfs_target::insert_watchpoint (CORE_ADDR addr, int len,
 {
   if (!target_have_steppable_watchpoint
       && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch ()))
-    {
-      /* When a hardware watchpoint fires off the PC will be left at
-	 the instruction following the one which caused the
-	 watchpoint.  It will *NOT* be necessary for GDB to step over
-	 the watchpoint.  */
-      return procfs_set_watchpoint (inferior_ptid, addr, len, type, 1);
-    }
+    /* When a hardware watchpoint fires off the PC will be left at
+       the instruction following the one which caused the
+       watchpoint.  It will *NOT* be necessary for GDB to step over
+       the watchpoint.  */
+    return procfs_set_watchpoint (inferior_ptid, addr, len, type, 1);
   else
-    {
-      /* When a hardware watchpoint fires off the PC will be left at
-	 the instruction which caused the watchpoint.  It will be
-	 necessary for GDB to step over the watchpoint.  */
-      return procfs_set_watchpoint (inferior_ptid, addr, len, type, 0);
-    }
+    /* When a hardware watchpoint fires off the PC will be left at
+       the instruction which caused the watchpoint.  It will be
+       necessary for GDB to step over the watchpoint.  */
+    return procfs_set_watchpoint (inferior_ptid, addr, len, type, 0);
 }
 
 int
@@ -3433,7 +3408,7 @@ iterate_over_mappings (procinfo *pi, find_memory_region_ftype child_func,
   /* Get the number of mappings, allocate space,
      and read the mappings into prmaps.  */
   /* Open map fd.  */
-  sprintf (pathname, "/proc/%d/map", pi->pid);
+  xsnprintf (pathname, sizeof (pathname), "/proc/%d/map", pi->pid);
 
   scoped_fd map_fd (open (pathname, O_RDONLY));
   if (map_fd.get () < 0)
@@ -3451,8 +3426,11 @@ iterate_over_mappings (procinfo *pi, find_memory_region_ftype child_func,
     proc_error (pi, "iterate_over_mappings (read)", __LINE__);
 
   for (prmap = prmaps; nmap > 0; prmap++, nmap--)
-    if ((funcstat = (*func) (prmap, child_func, data)) != 0)
-      return funcstat;
+    {
+      funcstat = (*func) (prmap, child_func, data);
+      if (funcstat != 0)
+	return funcstat;
+    }
 
   return 0;
 }
@@ -3658,9 +3636,7 @@ procfs_target::info_proc (const char *args, enum info_proc_what what)
     }
 
   if (mappings)
-    {
-      info_proc_mappings (process, 0);
-    }
+    info_proc_mappings (process, 0);
 
   return true;
 }
@@ -3891,8 +3867,9 @@ procfs_target::make_corefile_notes (bfd *obfd, int *note_size)
       psargs[sizeof (psargs) - 1] = 0;
 
       inf_args = get_inferior_args ();
-      if (inf_args && *inf_args &&
-	  strlen (inf_args) < ((int) sizeof (psargs) - (int) strlen (psargs)))
+      if (inf_args && *inf_args
+	  && (strlen (inf_args)
+	      < ((int) sizeof (psargs) - (int) strlen (psargs))))
 	{
 	  strncat (psargs, " ",
 		   sizeof (psargs) - strlen (psargs));