path: root/gprofng/src/gp-collect-app.cc

/* Copyright (C) 2021-2023 Free Software Foundation, Inc.
   Contributed by Oracle.

   This file is part of GNU Binutils.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */

#include "config.h"
#include <ctype.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/wait.h>
#include <sys/utsname.h>
#include <fcntl.h>
#include <signal.h>
#include <time.h>
#include <errno.h>
#include <sys/ptrace.h>

#include "gp-defs.h"
#include "cpu_frequency.h"
#include "util.h"
#include "collctrl.h"
#include "hwcdrv.h"
#include "gp-experiment.h"
#include "collect.h"
#include "StringBuilder.h"

#define SP_COLLECTOR_FOUNDER "SP_COLLECTOR_FOUNDER"

extern char **environ;

static volatile int interrupt = 0;
static int saved_stdout = -1;
static int  saved_stderr = -1;
static int no_short_usage = 0;
static int usage_fd = 2;
static collect *collect_obj = NULL;
extern "C" void sigint_handler (int sig, siginfo_t *info, void *context);
static char *outredirect = NULL;
static int precheck;
static int nprocesses;
static Process **processes;

int
main (int argc, char *argv[])
{
  // disable any alarm that might be pending
  int r = alarm (0);
  if (r != 0)
    dbe_write (2, GTXT ("collect has alarm(%d) pending\n"), r);
  collect_obj = new collect (argc, argv, environ);
  collect_obj->start (argc, argv);
  delete collect_obj;
  return 0;
}

extern "C" void
sigint_handler (int, siginfo_t *, void *)
{
  interrupt = 1;
  if (collect_obj->cc != NULL)
    collect_obj->cc->interrupt ();
  return;
}

extern "C" void
sigalrm_handler (int, siginfo_t *, void *)
{
  dbe_write (2, GTXT ("collect: unexpected alarm clock signal received\n"));
  return;
}

extern "C" void
sigterm_handler (int, siginfo_t *, void *)
{
  for (int i = 0; i < nprocesses; i++)
    {
      Process *proc = processes[i];
      if (proc != NULL)
	kill (proc->pid, SIGTERM);
    }
}

collect::collect (int argc, char *argv[], char **envp)
: Application (argc, argv)
{
  verbose = 0;
  disabled = 0;
  cc = NULL;
  collect_warnings = NULL;
  collect_warnings_idx = 0;
  int ii;
  for (ii = 0; ii < MAX_LD_PRELOAD_TYPES; ii++)
    sp_preload_list[ii] = NULL;
  for (ii = 0; ii < MAX_LD_PRELOAD_TYPES; ii++)
    sp_libpath_list[ii] = NULL;
  java_path = NULL;
  java_how = NULL;
  jseen_global = 0;
  nlabels = 0;
  origargc = argc;
  origargv = argv;
  origenvp = envp;
  mem_so_me = false;
}

collect::~collect ()
{
  delete cc;
}

struct sigaction old_sigint_handler;
struct sigaction old_sigalrm_handler;

void
collect::start (int argc, char *argv[])
{
  char *ccret;
  char *extype;
  /* create a collector control structure, disabling aggressive warning */
  cc = new Coll_Ctrl (0, false, false);
  if (prog_name)
    {
      char *s = strrchr (prog_name, '/');
      if (s && (s - prog_name) > 5) // Remove /bin/
	{
	  s = dbe_sprintf (NTXT ("%.*s"), (int) (s - prog_name - 4), prog_name);
	  cc->set_project_home (s);
	  free (s);
	}
    }
  char * errenable = cc->enable_expt ();
  if (errenable)
    {
      writeStr (2, errenable);
      free (errenable);
    }

  /* install a handler for SIGALRM */
  struct sigaction act;
  memset (&act, 0, sizeof (struct sigaction));
  sigemptyset (&act.sa_mask);
  act.sa_handler = (SignalHandler) sigalrm_handler;
  act.sa_flags = SA_RESTART | SA_SIGINFO;
  if (sigaction (SIGALRM, &act, &old_sigalrm_handler) == -1)
    {
      writeStr (2, GTXT ("Unable to install SIGALRM handler\n"));
      exit (-1);
    }

  /* install a handler for SIGINT */
  sigemptyset (&act.sa_mask);
  act.sa_handler = (SignalHandler) sigint_handler;
  act.sa_flags = SA_RESTART | SA_SIGINFO;
  if (sigaction (SIGINT, &act, &old_sigint_handler) == -1)
    {
      writeStr (2, GTXT ("Unable to install SIGINT handler\n"));
      exit (-1);
    }

  /* install a handler for SIGTERM */
  sigemptyset (&act.sa_mask);
  act.sa_sigaction = sigterm_handler;
  act.sa_flags = SA_RESTART | SA_SIGINFO;
  if (sigaction (SIGTERM, &act, NULL) == -1)
    {
      writeStr (2, GTXT ("Unable to install SIGTERM handler\n"));
      exit (-1);
    }
  if (argc > 1 && strncmp (argv[1], NTXT ("--whoami="), 9) == 0)
    {
      whoami = argv[1] + 9;
      argc--;
      argv++;
    }

  /* check for no arguments -- usage message */
  if (argc == 1)
    {
      verbose = 1;
      usage_fd = 1;
      validate_config (0);
      usage ();
      exit (0);
    }
  else if (argc == 2 && strcmp (argv[1], NTXT ("-h")) == 0)
    {
      /* only one argument, -h */
      verbose = 1;
      validate_config (0);
      /* now print the HWC usage message */
      show_hwc_usage ();
      exit (0);
    }
  else if (argc == 2 && (strcmp (argv[1], NTXT ("-help")) == 0 ||
			 strcmp (argv[1], NTXT ("--help")) == 0))
    {
      /* only one argument, -help or --help */
      verbose = 1;
      usage_fd = 1;
      validate_config (0);
      usage ();
      exit (0);
    }
// Ruud
  else if ((argc == 2) &&
	   (strcmp (argv[1], NTXT ("--version")) == 0))
    {
      /* only one argument, --version */

      /* print the version info */
      Application::print_version_info ();
      exit (0);
    }

  /* precheck the arguments -- scan for -O, -M flagS */
  precheck = 1;
  targ_index = check_args (argc, argv);
  if (targ_index < 0)
    {
      /* message has already been written */
      usage_fd = 2;
      short_usage ();
      exit (1);
    }
  /* crack the arguments */
  precheck = 0;
  targ_index = check_args (argc, argv);
  if (targ_index <= 0)
    {
      /* message has already been written */
      usage_fd = 2;
      short_usage ();
      exit (1);
    }
  if (targ_index != 0)
    check_target (argc, argv);
  if (disabled != 0 && cc->get_count () == 0)
    {
      // show collection parameters; count data
      ccret = cc->show (0);
      writeStr (1, ccret);
    }

  // see if Java version should be checked
  if (cc->get_java_default () == 0 && java_path != NULL)
    validate_java (java_path, java_how, verbose);

  /* if count data is requested, exec bit to do the real work */
  /* even for a dryrun */
  if (cc->get_count () != 0)
    get_count_data ();

  /* if a dry run, just exit */
  if (disabled != 0)
    {
      writeStr (1, cc->show_expt ());
      StringBuilder sb;
      sb.append (GTXT ("Exec argv[] = "));
      for (int i = 0; i < nargs; i++)
	sb.appendf (NTXT ("%s "), arglist[i]);
      sb.append (NTXT ("\n"));
      char *s = sb.toString ();
      writeStr (1, s);
      free (s);
      exit (0);
    }

  // If the mem_so_me flag is set, preload mem.so
  //	and launch the process
  if (mem_so_me)
    {
      /* set env vars for mem.so */
      if (putenv_memso () != 0)
	exit (1); /* message has already been written */
      /* ensure original outputs restored for target */
      reset_output ();

      /* now exec the target ... */
      if (cc->get_debug_mode () == 1)
	{
	  traceme (arglist[0], arglist);
	  extype = NTXT ("traceme");
	}
      else
	{
	  execvp (arglist[0], arglist);
	  extype = NTXT ("exevcp");
	}
      /* oops, exec of the target failed */
      char *em = strerror (errno);
      set_output ();    /* restore output for collector */
      if (em == NULL)
	dbe_write (2, GTXT ("memso %s of %s failed: errno = %d\n"), extype, argv[targ_index], errno);
      else
	dbe_write (2, GTXT ("memso %s of %s failed: %s\n"), extype, argv[targ_index], em);
      exit (1);
    }

  /* normal path, setting up an experiment and launching the target */
  /* set up the experiment */
  ccret = cc->setup_experiment ();
  if (ccret != NULL)
    {
      dbe_write (2, NTXT ("%s\n"), ccret);
      free (ccret);
      exit (1);
    }
  /* Beyond this point, the experiment is created */
  if (collect_warnings != NULL)
    {
      warn_open ();
      for (int i = 0; i < collect_warnings_idx; i++)
	warn_comment (SP_JCMD_CWARN, COL_WARN_APP_NOT_READY, collect_warnings[i], (int) strlen (collect_warnings[i]));
      warn_close ();
    }
  /* check cpu frequency variation for intel*/
  unsigned char mode = COL_CPUFREQ_NONE;
  int max_freq = get_cpu_frequency (&mode);
  char freq_scaling[256];
  char turbo_mode[256];
  *freq_scaling = 0;
  *turbo_mode = 0;
  if (mode & COL_CPUFREQ_SCALING)
    snprintf (freq_scaling, sizeof (freq_scaling), NTXT (" frequency_scaling=\"enabled\""));
  if (mode & COL_CPUFREQ_TURBO)
    snprintf (turbo_mode, sizeof (turbo_mode), NTXT (" turbo_mode=\"enabled\""));
  if (mode != COL_CPUFREQ_NONE)
    {
      warn_open ();
      if (warn_file != NULL)
	{
	  warn_write ("<powerm>\n<frequency clk=\"%d\"%s%s/>\n</powerm>\n",
		      max_freq, freq_scaling, turbo_mode);
	  warn_close ();
	}
    }

  /* check for labels to write to notes file */
  if (nlabels != 0)
    {
      char *nbuf;
      char nbuf2[MAXPATHLEN];
      // fetch the experiment name and CWD
      char *exp = cc->get_experiment ();
      char *ev = getcwd (nbuf2, sizeof (nbuf2));

      // format the environment variable for the experiment directory name
      if (ev != NULL && exp[0] != '/')
	// cwd succeeded, and experiment is a relative path
	nbuf = dbe_sprintf (NTXT ("%s/%s/%s"), nbuf2, exp, SP_NOTES_FILE);
      else
	// getcwd failed or experiment is a fullpath
	nbuf = dbe_sprintf (NTXT ("%s/%s"), exp, SP_NOTES_FILE);

      FILE *f = fopen (nbuf, NTXT ("w"));
      free (nbuf);
      if (f != NULL)
	{
	  for (int i = 0; i < nlabels; i++)
	    fprintf (f, NTXT ("%s\n"), label[i]);
	  fclose (f);
	}
    }
  /* check for user interrupt */
  if (interrupt == 1)
    {
      cc->delete_expt ();
      writeStr (2, GTXT ("User interrupt\n"));
      exit (0);
    }

  /* print data-collection parameters */
  if (verbose)
    {
      ccret = cc->show (0);
      if (ccret != NULL)
	writeStr (2, ccret);
    }
  ccret = cc->show_expt ();
  if (ccret != NULL)
    writeStr (1, ccret);    /* write this to stdout */

  pid_t pid = (pid_t) cc->get_attach_pid ();
  if (pid == (pid_t) 0)
    {
      /* No attach */
      /* Set the environment for libcollector */
      if (putenv_libcollector () != 0)
	{
	  /* message has already been written */
	  cc->delete_expt ();
	  exit (1);
	}
      /* ensure original output fds restored for target */
      reset_output ();

      /* now exec the target ... */
      if (cc->get_debug_mode () == 1)
	{
	  traceme (arglist[0], arglist);
	  extype = NTXT ("traceme");
	}
      else
	{
	  execvp (arglist[0], arglist);
	  extype = NTXT ("execvp");
	}

      /* we reach this point only if the target launch failed */
      char *em = strerror (errno);

      /* restore output for collector */
      set_output ();

      /* exec failed; delete experiment */
      cc->delete_expt ();

      /* print a message and exit */
      if (em == NULL)
	dbe_write (2, GTXT ("%s of %s failed: errno = %d\n"), extype, argv[targ_index], errno);
      else
	dbe_write (2, GTXT ("%s of %s failed: %s\n"), extype, argv[targ_index], em);
      exit (1);
    }
  else
    abort ();
}

/**
 * Prepare a warning message and pass it to warn_write()
 * @Parameters:
 * kind Type of comment
 * num ID
 * s Comment sting
 * len Length of the string
 * @Return: none.
 */
void
collect::warn_comment (const char *kind, int num, char *s, int len)
{
  if (len != 0)
    warn_write (NTXT ("<event kind=\"%s\" id=\"%d\">%.*s</event>\n"),
		kind, num, len, s);
  else if (s == NULL)
    warn_write (NTXT ("<event kind=\"%s\" id=\"%d\"/>\n"), kind, num);
  else
    warn_write (NTXT ("<event kind=\"%s\" id=\"%d\">%s</event>\n"), kind, num, s);
}

/**
 * Open the warnings file in Append mode ("aw")
 */
void
collect::warn_open ()
{
  // open the warnings file
  warnfilename = dbe_sprintf (NTXT ("%s/%s"), cc->get_experiment (), SP_WARN_FILE);
  int fd = open (warnfilename, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
  warn_file = fdopen (fd, NTXT ("aw"));
}

/**
 * Close the warnings file
 */
void
collect::warn_close ()
{
  (void) fclose (warn_file);
}

/**
 * Format the warning message and write it to the warnings file
 */
void
collect::warn_write (const char *format, ...)
{
  char buf[4096];
  // format the input arguments into a string
  va_list va;
  va_start (va, format);
  vsnprintf (buf, sizeof (buf), format, va);
  va_end (va);
  // write it to the warnings file (warnings.xml)
  fwrite (buf, 1, strlen (buf), warn_file);
  fflush (warn_file);
}

/* process the args, setting expt. params,
 *	and finding offset for a.out name
 */
int
collect::check_args (int argc, char *argv[])
{
  int hseen = 0;
  int hoffseen = 0;
  int lseen = 0;
  int tseen = 0;
  int pseen = 0;
  int sseen = 0;
  int yseen = 0;
  int Fseen = 0;
  int Aseen = 0;
  int Sseen = 0;
  int Hseen = 0;
  int iseen = 0;
  int Jseen = 0;
  int ofseen = 0;
  char *expName = NULL;
  bool overwriteExp = false;
  char *ccret;
  char *ccwarn;
  for (targ_index = 1; targ_index < argc; targ_index++)
    {
      if (argv[targ_index] == NULL)
	break;
      if (dbe_strcmp (argv[targ_index], "--") == 0)
	{
	  targ_index++;
	  break;
	}
      if (argv[targ_index][0] != '-')
	break;
      int param;
      switch (argv[targ_index][1])
	{
	case 'y':
	  {
	    if (precheck == 1)
	      {
		targ_index++;
		if (argv[targ_index] == NULL)
		  return 0;
		break;
	      }
	    char *ptr;
	    int resume = 1;
	    if (checkflagterm (argv[targ_index]) == -1) return -1;
	    if (yseen != 0)
	      {
		dupflagseen ('y');
		return -1;
	      }
	    yseen++;
	    targ_index++;
	    if (argv[targ_index] == NULL)
	      {
		writeStr (2, GTXT ("-y requires a signal argument\n"));
		return -1;
	      }
	    if ((ptr = strrchr (argv[targ_index], ',')) != NULL)
	      {
		if ((*(ptr + 1) != 'r') || (*(ptr + 2) != 0))
		  {
		    /* not the right trailer */
		    dbe_write (2, GTXT ("Invalid delay signal %s\n"), argv[targ_index]);
		    return -1;
		  }
		resume = 0;
		*ptr = 0;
	      }
	    param = cc->find_sig (argv[targ_index]);
	    if (param < 0)
	      {
		/* invalid signal */
		dbe_write (2, GTXT ("Invalid delay signal %s\n"), argv[targ_index]);
		return -1;
	      }
	    ccret = cc->set_pauseresume_signal (param, resume);
	    if (ccret != NULL)
	      {
		/* invalid signal; write message */
		writeStr (2, ccret);
		return -1;
	      }
	    break;
	  }
	case 'l':
	  if (precheck == 1)
	    {
	      targ_index++;
	      if (argv[targ_index] == NULL)
		return 0;
	      break;
	    }
	  if (checkflagterm (argv[targ_index]) == -1) return -1;
	  if (lseen != 0)
	    {
	      dupflagseen ('l');
	      return -1;
	    }
	  lseen++;
	  targ_index++;
	  if (argv[targ_index] == NULL)
	    {
	      writeStr (2, GTXT ("-l requires a signal argument\n"));
	      return -1;
	    }
	  param = cc->find_sig (argv[targ_index]);
	  if (param < 0)
	    {
	      /* invalid signal */
	      dbe_write (2, GTXT ("Invalid sample signal %s\n"), argv[targ_index]);
	      return -1;
	    }
	  ccret = cc->set_sample_signal (param);
	  if (ccret != NULL)
	    {
	      /* invalid signal; write message */
	      writeStr (2, ccret);
	      free (ccret);
	      return -1;
	    }
	  break;

#ifdef GPROFNG_DOES_NOT_SUPPORT
	case 'P':
	  if (precheck == 1)
	    {
	      targ_index++;
	      if (argv[targ_index] == NULL)
		return 0;
	      break;
	    }
	  if (checkflagterm (argv[targ_index]) == -1)
	    return -1;
	  if (Pseen != 0)
	    {
	      dupflagseen ('P');
	      return -1;
	    }
	  Pseen++;
	  targ_index++;
	  if (argv[targ_index] == NULL)
	    {
	      writeStr (2, GTXT ("-P requires a process pid argument\n"));
	      return -1;
	    }
	  ccret = cc->set_attach_pid (argv[targ_index]);
	  if (ccret != NULL)
	    {
	      /* error; write message */
	      writeStr (2, ccret);
	      free (ccret);
	      return -1;
	    }
	  break;
#endif
	case 't':
	  if (precheck == 1)
	    {
	      targ_index++;
	      if (argv[targ_index] == NULL)
		return 0;
	      break;
	    }

	  if (checkflagterm (argv[targ_index]) == -1) return -1;
	  if (tseen != 0)
	    {
	      dupflagseen ('t');
	      return -1;
	    }
	  tseen++;
	  targ_index++;
	  if (argv[targ_index] == NULL)
	    {
	      writeStr (2, GTXT ("-t requires a run-duration argument\n"));
	      return -1;
	    }
	  ccret = cc->set_time_run (argv[targ_index]);
	  if (ccret != NULL)
	    {
	      /* error; write message */
	      writeStr (2, ccret);
	      free (ccret);
	      return -1;
	    }
	  break;
	case 'p':
	  {
	    char *warnmsg;
	    if (precheck == 1)
	      {
		targ_index++;
		if (argv[targ_index] == NULL)
		  return 0;
		break;
	      }
	    if (checkflagterm (argv[targ_index]) == -1) return -1;
	    if (pseen != 0)
	      {
		dupflagseen ('p');
		return -1;
	      }
	    pseen++;
	    targ_index++;
	    if (argv[targ_index] == NULL)
	      {
		writeStr (2, GTXT ("-p requires a clock-profiling argument\n"));
		return -1;
	      }
	    ccret = cc->set_clkprof (argv[targ_index], &warnmsg);
	    if (ccret != NULL)
	      {
		writeStr (2, ccret);
		free (ccret);
		return -1;
	      }
	    if (warnmsg != NULL)
	      {
		writeStr (2, warnmsg);
		free (warnmsg);
	      }
	    break;
	  }
	case 's':
	  if (precheck == 1)
	    {
	      targ_index++;
	      if (argv[targ_index] == NULL)
		return 0;
	      break;
	    }
	  if (checkflagterm (argv[targ_index]) == -1) return -1;
	  if (sseen != 0)
	    {
	      dupflagseen ('s');
	      return -1;
	    }
	  sseen++;
	  targ_index++;
	  if (argv[targ_index] == NULL)
	    {
	      writeStr (2, GTXT ("-s requires a synchronization-tracing argument\n"));
	      return -1;
	    }
	  ccret = cc->set_synctrace (argv[targ_index]);
	  if (ccret != NULL)
	    {
	      writeStr (2, ccret);
	      free (ccret);
	      return -1;
	    }
	  break;
	case 'h':
	  {
	    if (precheck == 1)
	      {
		targ_index++;
		if (argv[targ_index] == NULL)
		  return 0;
		break;
	      }
	    if (checkflagterm (argv[targ_index]) == -1)
	      return -1;
	    targ_index++;
	    if ((argv[targ_index] == NULL) || (strlen (argv[targ_index]) == 0))
	      {
		writeStr (2, GTXT ("-h requires a HW-counter-profiling argument\n"));
		return -1;
	      }
	    // Check for some special cases
	    char * string = argv[targ_index];
	    if (strcmp (argv[targ_index], NTXT ("off")) == 0)
	      {
		if (hseen != 0)
		  {
		    no_short_usage = 1;
		    writeStr (2, GTXT ("-h off cannot be used with any other -h arguments\n"));
		    return -1;
		  }
		hoffseen = 1;
		hseen = 1;
		cc->disable_hwc ();
		break;
	      }
	    // Check to see if we can use HWC
	    unsigned hwc_maxregs = hwc_get_max_concurrent (false);
	    if (hwc_maxregs == 0)
	      {
		char buf[1024];
		char *pch = hwcfuncs_errmsg_get (buf, sizeof (buf), 0);
		if (*pch)
		  dbe_write (2, GTXT ("HW counter profiling is not supported on this system: %s%s"),
			     pch, pch[strlen (pch) - 1] == '\n' ? "" : "\n");
		else
		  dbe_write (2, GTXT ("HW counter profiling is not supported on this system\n"));
		no_short_usage = 1;
		return -1;
	      }
	    // Make sure there's no other -h after -h off
	    if (hoffseen != 0)
	      {
		no_short_usage = 1;
		writeStr (2, GTXT ("No -h arguments can be used after -h off\n"));
		return -1;
	      }
	    // set up to process HW counters (to know about default counters)
	    cc->setup_hwc ();
	    hseen++;
	    char *warnmsg;
	    if (strcmp (argv[targ_index], NTXT ("on")) == 0)
	      ccret = cc->add_default_hwcstring ("on", &warnmsg, true);
	    else if (strcmp (argv[targ_index], NTXT ("hi")) == 0 ||
		     strcmp (argv[targ_index], NTXT ("high")) == 0)
	      ccret = cc->add_default_hwcstring ("hi", &warnmsg, true);
	    else if (strcmp (argv[targ_index], NTXT ("lo")) == 0 ||
		     strcmp (argv[targ_index], NTXT ("low")) == 0)
	      ccret = cc->add_default_hwcstring ("lo", &warnmsg, true);
	    else if (strcmp (argv[targ_index], NTXT ("auto")) == 0)
	      ccret = cc->add_default_hwcstring ("auto", &warnmsg, true);
	    else
	      ccret = cc->add_hwcstring (string, &warnmsg);
	    if (ccret != NULL)
	      {
		/* set global flag to suppress the short_usage message for any subsequent HWC errors */
		no_short_usage = 1;
		writeStr (2, ccret);
		free (ccret);
		return -1;
	      }
	    if (warnmsg != NULL)
	      {
		writeStr (2, warnmsg);
		free (warnmsg);
	      }
	    break;
	  }
	case 'O':
	  overwriteExp = true;
	  ATTRIBUTE_FALLTHROUGH
	case 'o':
	  if (precheck == 1)
	    {
	      targ_index++;
	      if (argv[targ_index] == NULL)
		return 0;
	      break;
	    }
	  if (checkflagterm (argv[targ_index]) == -1)
	    return -1;
	  if (argv[targ_index + 1] == NULL)
	    {
	      dbe_write (2, GTXT ("Argument %s must be followed by a file name\n"),
			 argv[targ_index]);
	      return -1;
	    }
	  if (expName != NULL)
	    {
	      dbe_write (2, GTXT ("Only one -o or -O argument may be used\n"));
	      dupflagseen ('o');
	      return -1;
	    }
	  expName = argv[targ_index + 1];
	  targ_index++;
	  break;
	case 'S':
	  if (precheck == 1)
	    {
	      targ_index++;
	      if (argv[targ_index] == NULL)
		return 0;
	      break;
	    }
	  if (checkflagterm (argv[targ_index]) == -1) return -1;
	  if (argv[targ_index + 1] == NULL)
	    {
	      dbe_write (2, GTXT ("Argument %s must be followed by a sample interval name\n"),
			 argv[targ_index]);
	      return -1;
	    }
	  if (Sseen != 0)
	    {
	      dupflagseen ('S');
	      return -1;
	    }
	  Sseen++;
	  ccret = cc->set_sample_period (argv[targ_index + 1]);
	  if (ccret != NULL)
	    {
	      writeStr (2, ccret);
	      free (ccret);
	      return -1;
	    }
	  targ_index++;
	  break;
	case 'H':
	  if (precheck == 1)
	    {
	      targ_index++;
	      if (argv[targ_index] == NULL)
		return 0;
	      break;
	    }
	  if (checkflagterm (argv[targ_index]) == -1)
	    return -1;
	  if (argv[targ_index + 1] == NULL)
	    {
	      dbe_write (2, GTXT ("Argument %s requires a heap-tracing argument\n"),
			 argv[targ_index]);
	      return -1;
	    }
	  if (Hseen != 0)
	    {
	      dupflagseen ('H');
	      return -1;
	    }
	  Hseen++;
	  ccret = cc->set_heaptrace (argv[targ_index + 1]);
	  if (ccret != NULL)
	    {
	      writeStr (2, ccret);
	      free (ccret);
	      return -1;
	    }
	  if (cc->get_java_default () == 1)
	    cc->set_java_mode (NTXT ("off"));
	  targ_index++;
	  break;
	case 'i':
	  if (precheck == 1)
	    {
	      targ_index++;
	      if (argv[targ_index] == NULL)
		return 0;
	      break;
	    }
	  if (checkflagterm (argv[targ_index]) == -1)
	    return -1;
	  if (argv[targ_index + 1] == NULL)
	    {
	      fprintf (stderr, GTXT ("Argument %s requires an I/O-tracing argument\n"),
		       argv[targ_index]);
	      return -1;
	    }
	  if (iseen != 0)
	    {
	      dupflagseen ('i');
	      return -1;
	    }
	  iseen++;
	  ccret = cc->set_iotrace (argv[targ_index + 1]);
	  if (ccret != NULL)
	    {
	      writeStr (2, ccret);
	      free (ccret);
	      return -1;
	    }
	  targ_index++;
	  break;
	case 'j':
	  if (precheck == 1)
	    {
	      targ_index++;
	      if (argv[targ_index] == NULL)
		return 0;
	      break;
	    }
	  if (checkflagterm (argv[targ_index]) == -1) return -1;
	  if (argv[targ_index + 1] == NULL)
	    {
	      dbe_write (2, GTXT ("Argument %s requires a java-profiling argument\n"),
			 argv[targ_index]);
	      return -1;
	    }
	  if (jseen_global != 0)
	    {
	      dupflagseen ('j');
	      return -1;
	    }
	  jseen_global++;
	  ccret = cc->set_java_mode (argv[targ_index + 1]);
	  if (ccret != NULL)
	    {
	      writeStr (2, ccret);
	      free (ccret);
	      return -1;
	    }
	  targ_index++;
	  break;
	case 'J':
	  if (precheck == 1)
	    {
	      targ_index++;
	      if (argv[targ_index] == NULL)
		return 0;
	      break;
	    }
	  if (checkflagterm (argv[targ_index]) == -1) return -1;
	  if (argv[targ_index + 1] == NULL)
	    {
	      dbe_write (2, GTXT ("Argument %s requires a java argument\n"),
			 argv[targ_index]);
	      return -1;
	    }
	  if (Jseen != 0)
	    {
	      dupflagseen ('J');
	      return -1;
	    }
	  Jseen++;
	  ccret = cc->set_java_args (argv[targ_index + 1]);
	  if (ccret != NULL)
	    {
	      writeStr (2, ccret);
	      free (ccret);
	      return -1;
	    }
	  targ_index++;
	  break;
	case 'F':
	  if (precheck == 1)
	    {
	      targ_index++;
	      if (argv[targ_index] == NULL)
		return 0;
	      break;
	    }
	  if (checkflagterm (argv[targ_index]) == -1)
	    return -1;
	  if (argv[targ_index + 1] == NULL)
	    {
	      dbe_write (2, GTXT ("Argument %s requires a descendant-following argument\n"),
			 argv[targ_index]);
	      return -1;
	    }
	  if (Fseen != 0)
	    {
	      dupflagseen ('F');
	      return -1;
	    }
	  Fseen++;
	  ccret = cc->set_follow_mode (argv[targ_index + 1]);
	  if (ccret != NULL)
	    {
	      writeStr (2, ccret);
	      free (ccret);
	      return -1;
	    }
	  targ_index++;
	  break;
	case 'a':
	  if (precheck == 1)
	    {
	      targ_index++;
	      if (argv[targ_index] == NULL)
		return 0;
	      break;
	    }
	  if (checkflagterm (argv[targ_index]) == -1)
	    return -1;
	  if (argv[targ_index + 1] == NULL)
	    {
	      dbe_write (2, GTXT ("Argument %s requires a load-object archiving argument\n"),
			 argv[targ_index]);
	      return -1;
	    }
	  if (Aseen != 0)
	    {
	      dupflagseen ('a');
	      return -1;
	    }
	  Aseen++;
	  ccret = cc->set_archive_mode (argv[targ_index + 1]);
	  if (ccret != NULL)
	    {
	      writeStr (2, ccret);
	      free (ccret);
	      return -1;
	    }
	  targ_index++;
	  break;
	case 'C':
	  if (precheck == 1)
	    {
	      targ_index++;
	      if (argv[targ_index] == NULL)
		return 0;
	      break;
	    }
	  if (checkflagterm (argv[targ_index]) == -1)
	    return -1;
	  if (argv[targ_index + 1] == NULL)
	    {
	      dbe_write (2, GTXT ("Argument %s must be followed by a comment\n"),
			 argv[targ_index]);
	      return -1;
	    }
	  if (nlabels == MAXLABELS)
	    {
	      dbe_write (2, GTXT ("No more than %d comments may be specified\n"),
			 MAXLABELS);
	      return -1;
	    }
	  label[nlabels] = argv[targ_index + 1];
	  nlabels++;
	  targ_index++;
	  break;
	case 'n':
	case 'v':
	case 'V':
	  if (precheck == 1)
	    break;
	  do_flag (&argv[targ_index][1]);
	  break;
	case 'Z':
	  // special undocumented argument for debug builds only to allow analyzer to
	  // LD_PRELOAD mem.so for the target it spawns
	  mem_so_me = true;
	  break;
	case '-':
	  if (strcmp (argv[targ_index], NTXT ("--verbose")) == 0)
	    do_flag ("v");
	  else if (strcmp (argv[targ_index], "--outfile") == 0)
	    {
	      if (precheck == 0)
		{
		  targ_index++;
		  if (argv[targ_index] == NULL)
		    return 0;
		  break;
		}
	      // process this argument now
	      if (argv[targ_index + 1] == NULL)
		{
		  dbe_write (2, GTXT ("Argument %s requires a file argument\n"),
			     argv[targ_index]);
		  return -1;
		}
	      if (ofseen != 0)
		{
		  dupflagseen (argv[targ_index]);
		  return -1;
		}
	      ofseen++;
	      if (outredirect == NULL)
		{
		  outredirect = argv[targ_index + 1];
		  set_output ();
		} // else already redirected; ignore with no message
	      targ_index++;
	    }
	  else
	    {
	      dbe_write (2, GTXT ("collect: unrecognized argument `%s'\n"), argv[targ_index]);
	      return -1;
	    }
	  break;
	default:
	  dbe_write (2, GTXT ("collect: unrecognized argument `%s'\n"), argv[targ_index]);
	  return -1;
	}
    }
  if (targ_index >= argc)
    return -1;
  if (argv[targ_index] == NULL)
    {
      if (precheck == 1)
	return 0;
      if (cc->get_attach_pid () != 0)  /* no target is OK, if we're attaching */
	return 0;
      writeStr (2, GTXT ("Name of target must be specified\n"));
      return -1;
    }
  if (expName)
    {
      ccwarn = NULL;
      ccret = cc->set_expt (expName, &ccwarn, overwriteExp);
      if (ccwarn)
	{
	  writeStr (2, ccwarn);
	  free (ccwarn);
	}
      if (ccret)
	{
	  writeStr (2, ccret);
	  return -1;
	}
    }
  if (cc->get_attach_pid () != 0)
    {
      writeStr (2, GTXT ("Name of target must not be specified when -P is used\n"));
      return -1;
    }
  return targ_index;
}

int
collect::checkflagterm (const char *c)
{
  if (c[2] != 0)
    {
      dbe_write (2, GTXT ("collect: unrecognized argument `%s'\n"), c);
      return -1;
    }
  return 0;
}

int
collect::do_flag (const char *flags)
{
  char *s;
  for (int i = 0;; i++)
    {
      switch (flags[i])
	{
	case 0: // end of string
	  return 0;
	case 'n':
	  disabled = 1;
	  if (verbose != 1)
	    {
// Ruud
	      Application::print_version_info ();
/*
	      dbe_write (2, NTXT ("GNU %s version %s\n"),
			 get_basename (prog_name), VERSION);
*/
	      verbose = 1;
	    }
	  break;
	case 'x':
	  s = cc->set_debug_mode (1);
	  if (s)
	    {
	      writeStr (2, s);
	      free (s);
	    }
	  break;
	case 'v':
	  if (verbose != 1)
	    {
// Ruud
	      Application::print_version_info ();
/*
	      dbe_write (2, NTXT ("GNU %s version %s\n"),
			 get_basename (prog_name), VERSION);
*/
	      verbose = 1;
	    }
	  break;
	case 'V':
// Ruud
	  Application::print_version_info ();
/*
	  dbe_write (2, NTXT ("GNU %s version %s\n"),
		     get_basename (prog_name), VERSION);
*/
	  /* no further processing.... */
	  exit (0);
	}
    }
}

/*
 * traceme - cause the caller to stop at the end of the next exec()
 *	 so that a debugger can attach to the new program
 *
 * Takes same arguments as execvp()
 */
int
collect::traceme (const char *execvp_file, char *const execvp_argv[])
{
  int ret = -1;
  pid_t pid = fork ();
  if (pid == 0)
    { // child
      // child will set up itself to be PTRACE'd, and then exec the target executable
      /* reset the SP_COLLECTOR_FOUNDER value to the new pid */
      pid_t mypid = getpid ();
      char *ev = dbe_sprintf (NTXT ("%s=%d"), SP_COLLECTOR_FOUNDER, mypid);
      if (putenv (ev) != 0)
	{
	  dbe_write (2, GTXT ("fork-child: Can't putenv of \"%s\": run aborted\n"), ev);
	  return 1;
	}
      ptrace (PTRACE_TRACEME, 0, NULL, NULL); // initiate trace
      ret = execvp (execvp_file, execvp_argv); // execvp user command
      return ret; // execvp failed
    }
  else if (pid > 0)
    { // parent
      int status;
      if (waitpid (pid, &status, 0) != pid)
	{ // wait for execvp to cause signal
	  writeStr (2, GTXT ("parent waitpid() failed\n"));
	  return -2;
	}
      if (!WIFSTOPPED (status))
	writeStr (2, GTXT ("WIFSTOPPED(status) failed\n"));

      // originally, PTRACE_DETACH would send SIGTSTP, but now we do it here:
      if (kill (pid, SIGTSTP) != 0)
	writeStr (2, GTXT ("kill(pid, SIGTSTP) failed\n"));
      if (ptrace (PTRACE_DETACH, pid, NULL, 0) != 0)
	{ // detach trace
	  writeStr (2, GTXT ("ptrace(PTRACE_DETACH) failed\n"));
	  return -4;
	}
      dbe_write (2, GTXT ("Waiting for attach from debugger: pid=%d\n"), (int) pid);

      // wait for an external debugger to attach
      if (waitpid (pid, &status, 0) != pid)
	{ // keep parent alive until child quits
	  writeStr (2, GTXT ("parent final waitpid() failed\n"));
	  return -5;
	}
    }
  else
    return -1; // fork failed
  exit (0);
}

void
collect::dupflagseen (char c)
{
  dbe_write (2, GTXT ("Only one -%c argument may be used\n"), c);
}

void
collect::dupflagseen (const char *s)
{
  dbe_write (2, GTXT ("Only one %s argument may be used\n"), s);
}

int
collect::set_output ()
{
  static int initial = 1;
  if (outredirect)
    {
      int fd = open (outredirect, O_WRONLY | O_CREAT | O_APPEND,
		     S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
      if (fd == -1)
	{
	  dbe_write (2, GTXT ("Warning: Can't open collector output `%s': %s\n"),
		     outredirect, strerror (errno));
	}
      else
	{
	  if ((saved_stdout = dup (1)) == -1 || dup2 (fd, 1) == -1)
	    dbe_write (2, GTXT ("Warning: Can't divert collector %s: %s\n"),
		       NTXT ("stdout"), strerror (errno));
	  if ((saved_stderr = dup (2)) == -1 || dup2 (fd, 2) == -1)
	    dbe_write (2, GTXT ("Warning: Can't divert collector %s: %s\n"),
		       NTXT ("stderr"), strerror (errno));
	  close (fd);
	  if ((saved_stdout != -1) && (saved_stderr != -1))
	    {
	      if (initial)
		{
		  struct timeval tp;
		  gettimeofday (&tp, NULL);
		  writeStr (2, ctime (&tp.tv_sec));
		  initial = 0;
		}
	      return 1; // diversion in place
	    }
	}
    }
  return 0; // no diversion
}

void
collect::reset_output ()
{
  if (saved_stdout != -1 &&
      (dup2 (saved_stdout, 1) == -1 || close (saved_stdout)))
    dbe_write (2, GTXT ("Warning: Can't restore collector stdout: %s\n"),
	       strerror (errno));
  if (saved_stderr != -1 &&
      (dup2 (saved_stderr, 2) == -1 || close (saved_stderr)))
    dbe_write (2, GTXT ("Warning: Can't restore collector stderr: %s\n"),
	       strerror (errno));
}

void
collect::usage ()
{

/*
  Ruud - Isolate this line because it has an argument.  Otherwise it would be at the
  end of this long list.
*/
  printf ( GTXT (
    "Usage: gprofng collect app [OPTION(S)] TARGET [TARGET_ARGUMENTS]\n")),

/*
-------------------------------------------------------------------------------
  For a reason I don't understand, the continuation line(s) need to start at
  column 26 in order for help2man to do the righ thing. Ruud
-------------------------------------------------------------------------------
*/
  printf ( GTXT (
    "\n"
    "Collect performance data on the target program. In addition to Program\n"
    "Counter PC) sampling, hardware event counters and various tracing options\n"
    "are supported.\n"
    "\n"
    "Options:\n"
    "\n"
    " --version           print the version number and exit.\n"
    " --help              print usage information and exit.\n"
    " --verbose {on|off}  enable (on) or disable (off) verbose mode; the default is \"off\".\n"
    "\n"
    " -p {off|on|lo|hi|<value>}  disable (off) or enable (on) clock-profiling using a default\n"
    "                    sampling granularity, or enable clock-profiling implicitly by\n"
    "                    setting the sampling granularity (lo, hi, or a specific value\n"
    "                    in ms); by default clock profiling is enabled.\n"
    "\n"
    " -h {<ctr_def>...,<ctr_n_def>}  enable hardware event counter profiling and select\n"
    "                    the counter(s); to see the supported counters on this system use\n"
    "                    the -h option without other arguments.\n"
    "\n"
    " -o <exp_name>     specify the name for (and path to) the experiment directory; the\n"
    "                    the default path is the current directory.\n"
    "\n"
    " -O <exp_name>     the same as -o, but unlike the -o option, silently overwrite an\n"
    "                    existing experiment directory with the same name.\n"
    "\n"
    " -C <label>        add up to 10 comment labels to the experiment; comments appear in\n"
    "                    the notes section of the header.\n"
    "\n"
    " -j {on|off|<path>} enable (on), or disable (off) Java profiling when the target\n"
    "                     program is a JVM; optionally set the <path> to a non-default JVM;\n"
    "                     the default is \"-j on\".\n"
    "\n"
    " -J <java-args>    specify arguments to the JVM.\n"
    "\n"
    " -t <duration>[m|s]  specify the duration over which to record data; the default unit\n"
    "                      is seconds (s), but can be set to minutes (m).\n"
    "\n"
    " -n                  dry run; display several run-time settings, but do not run the\n"
    "                      target, or collect performance data.\n"
    "\n"
    " -y <signal>[,r]     specify delayed initialization and a pause/resume signal; by default\n"
    "                      the target starts in paused mode; if the optional r keyword is\n"
    "                      provided, start in resumed mode.\n"
    "\n"
    " -F {off|on|=<regex>}  control to follow descendant processes; disable (off), enable (on),\n"
    "                        or collect data on all descendant processes whose name matches the\n"
    "                        specified regular expression; the default is \"-F on\".\n"
    "\n"
    " -a {off|on|ldobjects|src|usedldobjects|usedsrc}  specify archiving of binaries and other files;\n"
    "                    in addition to disable this feature (off), or enable archiving off all\n"
    "                    loadobjects and sources (on), the other options support a more\n"
    "                    refined selection. All of these options enable archiving, but the\n"
    "                    keyword controls what exactly is selected: all load objects (ldobjects),\n"
    "                    all source files (src), the loadobjects asscoiated with a program counter\n"
    "                    (usedldobjects), or the source files associated with a program counter\n"
    "                    (usedsrc); the default is \"-a ldobjects\".\n"
    "\n"
    " -S {off|on|<seconds>}  disable (off) or enable (on) periodic sampling of process-wide resource\n"
    "                         utilization; by default sampling occurs every second; use the <seconds>\n"
    "                         option to change this; the default is \"-S on\".\n"
    "\n"
    " -l <signal>       specify a signal that will trigger a sample of process-wide resource utilization.\n"
    "\n"
    " -s <option>[,<API>]  enable synchronization wait tracing; <option> is used to define the specifics\n"
    "                       of the tracing (on, off, <threshold>, or all); <API> is used to select the API:\n"
    "                       \"n\" selects native/Pthreads, \"j\" selects Java, and \"nj\" selects both;\n"
    "                       the default is \"-s off\".\n"
    "\n"
    " -H {off|on}        disable (off), or enable (on) heap tracing; the default is \"-H off\".\n"
    "\n"
    " -i {off|on}        disable (off), or enable (on) I/O tracing; the default is \"-i off\".\n"
    "\n"
    "Documentation:\n"
    "\n"
    "A getting started guide for gprofng is maintained as a Texinfo manual. If the info and\n"
    "gprofng programs are properly installed at your site, the command \"info gprofng\"\n"
    "should give you access to this document.\n"
    "\n"
    "See also:\n"
    "\n"
    "gprofng(1), gp-archive(1), gp-display-html(1), gp-display-src(1), gp-display-text(1)\n"));
/*
  char *s = dbe_sprintf (GTXT ("Usage:  %s <args> target <target-args>\n"),
			 whoami);
  writeStr (usage_fd, s);
  free (s);
  writeStr (usage_fd, GTXT ("  -p {lo|on|hi|off|<value>}\tspecify clock-profiling\n"));
  writeStr (usage_fd, GTXT ("\t`lo'    per-thread rate of ~10 samples/second\n"));
  writeStr (usage_fd, GTXT ("\t`on'    per-thread rate of ~100 samples/second (default)\n"));
  writeStr (usage_fd, GTXT ("\t`hi'    per-thread rate of ~1000 samples/second\n"));
  writeStr (usage_fd, GTXT ("\t`off'   disable clock profiling\n"));
  writeStr (usage_fd, GTXT ("\t<value> specify profile timer period in millisec.\n"));
  s = dbe_sprintf (GTXT ("\t\t\tRange on this system is from %.3f to %.3f millisec.\n\t\t\tResolution is %.3f millisec.\n"),
		   (double) cc->get_clk_min () / 1000.,
		   (double) cc->get_clk_max () / 1000.,
		   (double) cc->get_clk_res () / 1000.);
  writeStr (usage_fd, s);
  free (s);
  writeStr (usage_fd, GTXT ("  -h <ctr_def>...[,<ctr_n_def>]\tspecify HW counter profiling\n"));
  s = dbe_sprintf (GTXT ("\tto see the supported HW counters on this machine, run \"%s -h\" with no other arguments\n"),
		   whoami);
  writeStr (usage_fd, s);
  free (s);
  writeStr (usage_fd, GTXT ("  -s <threshold>[,<scope>]\tspecify synchronization wait tracing\n"));
  writeStr (usage_fd, GTXT ("\t<scope> is \"j\" for tracing Java-APIs, \"n\" for tracing native-APIs, or \"nj\" for tracing both\n"));
  writeStr (usage_fd, GTXT ("  -H {on|off}\tspecify heap tracing\n"));
  writeStr (usage_fd, GTXT ("  -i {on|off}\tspecify I/O tracing\n"));
  writeStr (usage_fd, GTXT ("  -N <lib>\tspecify library to exclude count from instrumentation (requires -c also)\n"));
  writeStr (usage_fd, GTXT ("          \tmultiple -N arguments can be provided\n"));
  writeStr (usage_fd, GTXT ("  -j {on|off|path}\tspecify Java profiling\n"));
  writeStr (usage_fd, GTXT ("  -J <java-args>\tspecify arguments to Java for Java profiling\n"));
  writeStr (usage_fd, GTXT ("  -t <duration>\tspecify time over which to record data\n"));
  writeStr (usage_fd, GTXT ("  -n\tdry run -- don't run target or collect performance data\n"));
  writeStr (usage_fd, GTXT ("  -y <signal>[,r]\tspecify delayed initialization and pause/resume signal\n"));
  writeStr (usage_fd, GTXT ("\tWhen set, the target starts in paused mode;\n\t  if the optional r is provided, it starts in resumed mode\n"));
  writeStr (usage_fd, GTXT ("  -F {on|off|=<regex>}\tspecify following descendant processes\n"));
  writeStr (usage_fd, GTXT ("  -a {on|ldobjects|src|usedldobjects|usedsrc|off}\tspecify archiving of binaries and other files;\n"));
  writeStr (usage_fd, GTXT ("  -S {on|off|<seconds>}\t Set the interval for periodic sampling of process-wide resource utilization\n"));
  writeStr (usage_fd, GTXT ("  -l <signal>\tspecify signal that will trigger a sample of process-wide resource utilization\n"));
  writeStr (usage_fd, GTXT ("  -o <expt>\tspecify experiment name\n"));
  writeStr (usage_fd, GTXT ("  --verbose\tprint expanded log of processing\n"));
  writeStr (usage_fd, GTXT ("  -C <label>\tspecify comment label (up to 10 may appear)\n"));
  writeStr (usage_fd, GTXT ("  -V|--version\tprint version number and exit\n"));
*/
  /* don't document this feature */
  //	writeStr (usage_fd, GTXT("  -Z\tPreload mem.so, and launch target [no experiment]\n") );
/*
  writeStr (usage_fd, GTXT ("\n See the gp-collect(1) man page for more information\n"));
*/

#if 0
  /* print an extended usage message */
  /* find a Java for Java profiling, set Java on to check Java */
  find_java ();
  cc->set_java_mode (NTXT ("on"));

  /* check for variable-clock rate */
  unsigned char mode = COL_CPUFREQ_NONE;
  get_cpu_frequency (&mode);
  if (mode != COL_CPUFREQ_NONE)
    writeStr (usage_fd, GTXT ("NOTE: system has variable clock frequency, which may cause variable program run times.\n"));

  /* show the experiment that would be run */
  writeStr (usage_fd, GTXT ("\n Default experiment:\n"));
  char *ccret = cc->setup_experiment ();
  if (ccret != NULL)
    {
      writeStr (usage_fd, ccret);
      free (ccret);
      exit (1);
    }
  cc->delete_expt ();
  ccret = cc->show (1);
  if (ccret != NULL)
    {
      writeStr (usage_fd, ccret);
      free (ccret);
    }
#endif
}

void
collect::short_usage ()
{
  if (no_short_usage == 0)
    dbe_write (usage_fd, GTXT ("Run \"%s --help\" for a usage message.\n"), whoami);
}

void
collect::show_hwc_usage ()
{
  usage_fd = 1;
  short_usage ();
  cc->setup_hwc ();
  hwc_usage (false, whoami, NULL);
}

void
collect::writeStr (int f, const char *buf)
{
  if (buf != NULL)
    write (f, buf, strlen (buf));
}