/*-
 * Copyright (c) 1983, 1992, 1993
 *	The Regents of the University of California.  All rights reserved.
 * Copyright (C) 2007-2016 Free Software Foundation, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
#if 0
#include <sys/param.h>
#include <sys/time.h>
#endif
#include <sys/gmon.h>
#include <sys/gmon_out.h>

#include <stddef.h>
#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#if 0
#include <libc-internal.h>
#include <not-cancel.h>

#ifdef USE_IN_LIBIO
# include <wchar.h>
#endif
#endif
#define internal_function
#define weak_alias(fun,aliasid) extern __typeof(fun) aliasid __attribute__ ((weak, alias (#fun)));
#define __libc_enable_secure 0

/*  Head of basic-block list or NULL. */
struct __bb *__bb_head attribute_hidden;

struct gmonparam _gmonparam attribute_hidden = { GMON_PROF_OFF };

/*
 * See profil(2) where this is described:
 */
static int	s_scale;
#define		SCALE_1_TO_1	0x10000L

#define ERR(s) write (STDERR_FILENO, s, sizeof (s) - 1)

void moncontrol (int mode);
void __moncontrol (int mode);
static void write_hist (int fd) internal_function;
static void write_call_graph (int fd) internal_function;
static void write_bb_counts (int fd) internal_function;

/*
 * Control profiling
 *	profiling is what mcount checks to see if
 *	all the data structures are ready.
 */
void
__moncontrol (int mode)
{
  struct gmonparam *p = &_gmonparam;

  /* Don't change the state if we ran into an error.  */
  if (p->state == GMON_PROF_ERROR)
    return;

  if (mode)
    {
      /* start */
      __profil((void *) p->kcount, p->kcountsize, p->lowpc, s_scale);
      p->state = GMON_PROF_ON;
    }
  else
    {
      /* stop */
      __profil(NULL, 0, 0, 0);
      p->state = GMON_PROF_OFF;
    }
}
weak_alias (__moncontrol, moncontrol)


void
__monstartup (u_long lowpc, u_long highpc)
{
  register int o;
  char *cp;
  struct gmonparam *p = &_gmonparam;
  int linesz;

  /*
   * round lowpc and highpc to multiples of the density we're using
   * so the rest of the scaling (here and in gprof) stays in ints.
   */
  p->lowpc = ROUNDDOWN(lowpc, HISTFRACTION * sizeof(HISTCOUNTER));
  if (sizeof *p->froms % sizeof(HISTCOUNTER) != 0)
    {
      p->highpc = ROUNDUP(highpc, HISTFRACTION * sizeof(HISTCOUNTER));
      p->textsize = p->highpc - p->lowpc;
      p->kcountsize = ROUNDUP((p->textsize + HISTFRACTION - 1) / HISTFRACTION,
			      sizeof (*p->froms));
    }
  else
    {
      /* Avoid odd scales by rounding up highpc to get kcountsize rounded.  */
      p->textsize = ROUNDUP (highpc - p->lowpc,
			     HISTFRACTION * sizeof (*p->froms));
      p->highpc = p->lowpc + p->textsize;
      p->kcountsize = p->textsize / HISTFRACTION;
    }
  p->hashfraction = HASHFRACTION;
  p->log_hashfraction = -1;
  /* The following test must be kept in sync with the corresponding
     test in mcount.c.  */
  if ((HASHFRACTION & (HASHFRACTION - 1)) == 0) {
      /* if HASHFRACTION is a power of two, mcount can use shifting
	 instead of integer division.  Precompute shift amount. */
      p->log_hashfraction = ffs(p->hashfraction * sizeof(*p->froms)) - 1;
  }
  p->tolimit = p->textsize * ARCDENSITY / 100;
  if (p->tolimit < MINARCS)
    p->tolimit = MINARCS;
  else if (p->tolimit > MAXARCS)
    p->tolimit = MAXARCS;
  p->tossize = p->tolimit * sizeof(struct tostruct);

  /* p->kcount must not share cache lines with the adjacent data, because
     we use uncached accesses while profiling.  */
  linesz = __dcache_linesz ();
  cp = calloc (ROUNDUP (p->kcountsize, linesz) + p->tossize
	       + (linesz - 1), 1);
  if (! cp)
    {
      ERR("monstartup: out of memory\n");
      p->tos = NULL;
      p->state = GMON_PROF_ERROR;
      /* In case we loose the error state due to a race,
	 prevent invalid writes also by clearing tolimit.  */
      p->tolimit = 0;
      return;
    }
  p->tos = (struct tostruct *)cp;
  cp += p->tossize;
  cp = (char *) ROUNDUP ((ptrdiff_t) cp, linesz);
  p->kcount = (HISTCOUNTER *)cp;
  cp += ROUNDUP (p->kcountsize, linesz);

  p->tos[0].link = 0;

  o = p->highpc - p->lowpc;
  if (p->kcountsize < (u_long) o)
    {
#ifndef hp300
      s_scale = ((float)p->kcountsize / o ) * SCALE_1_TO_1;
#else
      /* avoid floating point operations */
      int quot = o / p->kcountsize;

      if (quot >= 0x10000)
	s_scale = 1;
      else if (quot >= 0x100)
	s_scale = 0x10000 / quot;
      else if (o >= 0x800000)
	s_scale = 0x1000000 / (o / (p->kcountsize >> 8));
      else
	s_scale = 0x1000000 / ((o << 8) / p->kcountsize);
#endif
    } else
      s_scale = SCALE_1_TO_1;

  __moncontrol(1);
}
weak_alias (__monstartup, monstartup)


static void
internal_function
write_hist (int fd)
{
  u_char tag = GMON_TAG_TIME_HIST;
  struct arc_gmon_hist_hdr thdr __attribute__ ((aligned (__alignof__ (char *))));
  int r;

  if (_gmonparam.kcountsize > 0)
    {
      *(char **) thdr.low_pc = (char *) _gmonparam.lowpc;
      *(char **) thdr.high_pc = (char *) _gmonparam.highpc;
      *(int32_t *) thdr.hist_size = (_gmonparam.kcountsize
				     / sizeof (HISTCOUNTER));
      *(int32_t *) thdr.prof_rate = __profile_frequency ();
      strncpy (thdr.dimen, "seconds", sizeof (thdr.dimen));
      thdr.dimen_abbrev = 's';

      r = write (fd, &tag, sizeof tag);
      if (r != sizeof tag)
	return;
      r = write (fd, &thdr, sizeof thdr);
      if (r != sizeof thdr)
	return;
      r = write (fd,_gmonparam.kcount, _gmonparam.kcountsize);
      if ((unsigned) r != _gmonparam.kcountsize)
	return;
    }
}


static void
internal_function
write_call_graph (int fd)
{
#define NARCS_PER_WRITE	64
#define BYTES_PER_ARC (1 + sizeof (struct gmon_cg_arc_record))
#define BYTES_PER_WRITE (BYTES_PER_ARC * NARCS_PER_WRITE)
  ARCINDEX to_index;
  u_long frompc, selfpc, count;
  char buffer[BYTES_PER_WRITE], *p;
  u_long *prof_desc = __arc_profile_desc_secstart;
  u_long *prof_count = __arc_profile_counters_secstart;
  u_long *prof_desc_end = __arc_profile_desc_secend;
  u_long *prof_forward = __arc_profile_forward_secstart;

  for (p = buffer; p < buffer + BYTES_PER_WRITE; p += BYTES_PER_ARC)
    *p = GMON_TAG_CG_ARC;
  p = buffer;
  frompc = *prof_desc++ & -2;
  while (prof_desc < prof_desc_end)
    {
      selfpc = *prof_desc++;
      if (selfpc & 1)
	{
	  frompc = selfpc & -2;
	  selfpc = *prof_desc++;
	}
      count = *prof_count++;
      if (selfpc)
	{
	  struct arc
	    {
	      char *frompc;
	      char *selfpc;
	      int32_t count;
	    }
	  arc;

	  if (!count)
	    continue;
	  arc.frompc = (char *) frompc;
	  arc.selfpc = (char *) selfpc;
	  arc.count  = count;
	  memcpy (p + 1, &arc, sizeof arc);
	  p += 1 + sizeof arc;

	  if (p == buffer + BYTES_PER_WRITE)
	    {
	      write (fd, buffer, BYTES_PER_WRITE);
	      p = buffer;
	    }
	}
      else
	{
	  for (to_index = count;
	       to_index != 0;
	       to_index = _gmonparam.tos[to_index].link)
	    {
	      struct arc
		{
		  char *frompc;
		  char *selfpc;
		  int32_t count;
		}
	      arc;

	      arc.frompc = (char *) frompc;
	      arc.selfpc = (char *) _gmonparam.tos[to_index].selfpc;
	      arc.count  = _gmonparam.tos[to_index].count;
	      memcpy (p + 1, &arc, sizeof arc);
	      p += 1 + sizeof arc;

	      if (p == buffer + BYTES_PER_WRITE)
		{
		  write (fd, buffer, BYTES_PER_WRITE);
		  p = buffer;
		}
	    }
	}
    }
  while (prof_forward < __arc_profile_forward_secend)
    {
      /* ??? The 'call count' is actually supposed to be a fixed point
	 factor, with 16 bits each before and after the point.
	 It would be much nicer if we figured out the actual number
	 of calls to the caller, and multiplied that with the fixed point
	 factor to arrive at the estimated calls for the callee.  */
      memcpy (p + 1, prof_forward, 3 * sizeof *prof_forward);
      prof_forward += 3;
      p += 1 + 3 * sizeof *prof_forward;
      if (p == buffer + BYTES_PER_WRITE)
	{
	  write (fd, buffer, BYTES_PER_WRITE);
	  p = buffer;
	}
    }
  if (p != buffer)
    write (fd, buffer, p - buffer);
}


static void
internal_function
write_bb_counts (int fd)
{
  struct __bb *grp;
  u_char tag = GMON_TAG_BB_COUNT;
  size_t ncounts;
  size_t i;

  struct { unsigned long address; long count; } bbbody[8];
  size_t nfilled;

  /* Write each group of basic-block info (all basic-blocks in a
     compilation unit form a single group). */

  for (grp = __bb_head; grp; grp = grp->next)
    {
      ncounts = grp->ncounts;
      write (fd, &tag, 1);
      write (fd, &ncounts, sizeof ncounts);
      for (nfilled = i = 0; i < ncounts; ++i)
	{
	  if (nfilled == sizeof (bbbody) / sizeof (bbbody[0]))
	    {
	      write (fd, bbbody, sizeof bbbody);
	      nfilled = 0;
	    }

	  bbbody[nfilled].address = grp->addresses[i];
	  bbbody[nfilled++].count = grp->counts[i];
	}
      if (nfilled > 0)
	write (fd, bbbody, nfilled * sizeof bbbody[0]);
    }
}


static void
write_gmon (void)
{
    struct gmon_hdr ghdr __attribute__ ((aligned (__alignof__ (int))));
    int fd = -1;
    char *env;

#ifndef O_NOFOLLOW
# define O_NOFOLLOW	0
#endif

    env = getenv ("GMON_OUT_PREFIX");
    if (env != NULL && !__libc_enable_secure)
      {
	size_t len = strlen (env);
	char buf[len + 20];
	snprintf (buf, sizeof (buf), "%s.%u", env, getpid ());
	fd = open (buf, O_CREAT|O_TRUNC|O_WRONLY|O_NOFOLLOW, 0666);
      }

    if (fd == -1)
      {
	fd = open ("gmon.out", O_CREAT|O_TRUNC|O_WRONLY|O_NOFOLLOW,
			      0666);
	if (fd < 0)
	  {
	    perror ("_mcleanup: gmon.out");
	    return;
	  }
      }

    /* write gmon.out header: */
    memset (&ghdr, '\0', sizeof (struct gmon_hdr));
    memcpy (&ghdr.cookie[0], GMON_MAGIC, sizeof (ghdr.cookie));
    *(int32_t *) ghdr.version = GMON_VERSION;
    write (fd, &ghdr, sizeof (struct gmon_hdr));

    /* write PC histogram: */
    write_hist (fd);

    /* write call-graph: */
    write_call_graph (fd);

    /* write basic-block execution counts: */
    write_bb_counts (fd);

    close (fd);
}


void
__write_profiling (void)
{
  int save = _gmonparam.state;
  _gmonparam.state = GMON_PROF_OFF;
  if (save == GMON_PROF_ON)
    write_gmon ();
  _gmonparam.state = save;
}
#ifndef SHARED
/* This symbol isn't used anywhere in the DSO and it is not exported.
   This would normally mean it should be removed to get the same API
   in static libraries.  But since profiling is special in static libs
   anyway we keep it.  But not when building the DSO since some
   quality assurance tests will otherwise trigger.  */
weak_alias (__write_profiling, write_profiling)
#endif


void
_mcleanup (void)
{
  __moncontrol (0);

  if (_gmonparam.state != GMON_PROF_ERROR)
    write_gmon ();

  /* free the memory. */
  if (_gmonparam.tos != NULL)
    free (_gmonparam.tos);
}
