Subversion Repositories openrisc

/* Routines required for instrumenting a program.  */

/* Compile this one with gcc.  */

/* Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,

   2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009, 2010, 2011

   Free Software Foundation, Inc.

This file is part of GCC.

GCC 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.

GCC 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.

Under Section 7 of GPL version 3, you are granted additional

permissions described in the GCC Runtime Library Exception, version

3.1, as published by the Free Software Foundation.

You should have received a copy of the GNU General Public License and

a copy of the GCC Runtime Library Exception along with this program;

see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

<http://www.gnu.org/licenses/>.  */

#include "tconfig.h"

#include "tsystem.h"

#include "coretypes.h"

#include "tm.h"

#include "libgcc_tm.h"

#if defined(inhibit_libc)

#define IN_LIBGCOV (-1)

#else

#undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */

#include <stdio.h>

#define IN_LIBGCOV 1

#if defined(L_gcov)

#define GCOV_LINKAGE /* nothing */

#endif

#endif

#include "gcov-io.h"

#if defined(inhibit_libc)

/* If libc and its header files are not available, provide dummy functions.  */

#ifdef L_gcov

void __gcov_init (struct gcov_info *p __attribute__ ((unused))) {}

void __gcov_flush (void) {}

#endif

#ifdef L_gcov_merge_add

void __gcov_merge_add (gcov_type *counters  __attribute__ ((unused)),

                       unsigned n_counters __attribute__ ((unused))) {}

#endif

#ifdef L_gcov_merge_single

void __gcov_merge_single (gcov_type *counters  __attribute__ ((unused)),

                          unsigned n_counters __attribute__ ((unused))) {}

#endif

#ifdef L_gcov_merge_delta

void __gcov_merge_delta (gcov_type *counters  __attribute__ ((unused)),

                         unsigned n_counters __attribute__ ((unused))) {}

#endif

#else

#include <string.h>

#if GCOV_LOCKED

#include <fcntl.h>

#include <errno.h>

#include <sys/stat.h>

#endif

#ifdef L_gcov

#include "gcov-io.c"

struct gcov_fn_buffer

{

  struct gcov_fn_buffer *next;

  unsigned fn_ix;

  struct gcov_fn_info info;

  /* note gcov_fn_info ends in a trailing array.  */

};

/* Chain of per-object gcov structures.  */

static struct gcov_info *gcov_list;

/* Size of the longest file name. */

static size_t gcov_max_filename = 0;

/* Make sure path component of the given FILENAME exists, create

   missing directories. FILENAME must be writable.

   Returns zero on success, or -1 if an error occurred.  */

static int

create_file_directory (char *filename)

{

#if !defined(TARGET_POSIX_IO) && !defined(_WIN32)

  (void) filename;

  return -1;

#else

  char *s;

  s = filename;

  if (HAS_DRIVE_SPEC(s))

    s += 2;

  if (IS_DIR_SEPARATOR(*s))

    ++s;

  for (; *s != '\0'; s++)

    if (IS_DIR_SEPARATOR(*s))

      {

        char sep = *s;

        *s  = '\0';

        /* Try to make directory if it doesn't already exist.  */

        if (access (filename, F_OK) == -1

#ifdef TARGET_POSIX_IO

            && mkdir (filename, 0755) == -1

#else

            && mkdir (filename) == -1

#endif

            /* The directory might have been made by another process.  */

            && errno != EEXIST)

          {

            fprintf (stderr, "profiling:%s:Cannot create directory\n",

                     filename);

            *s = sep;

            return -1;

          };

        *s = sep;

      };

  return 0;

#endif

}

static struct gcov_fn_buffer *

free_fn_data (const struct gcov_info *gi_ptr, struct gcov_fn_buffer *buffer,

              unsigned limit)

{

  struct gcov_fn_buffer *next;

  unsigned ix, n_ctr = 0;

  if (!buffer)

    return 0;

  next = buffer->next;

  for (ix = 0; ix != limit; ix++)

    if (gi_ptr->merge[ix])

      free (buffer->info.ctrs[n_ctr++].values);

  free (buffer);

  return next;

}

static struct gcov_fn_buffer **

buffer_fn_data (const char *filename, const struct gcov_info *gi_ptr,

                struct gcov_fn_buffer **end_ptr, unsigned fn_ix)

{

  unsigned n_ctrs = 0, ix = 0;

  struct gcov_fn_buffer *fn_buffer;

  unsigned len;

  for (ix = GCOV_COUNTERS; ix--;)

    if (gi_ptr->merge[ix])

      n_ctrs++;

  len = sizeof (*fn_buffer) + sizeof (fn_buffer->info.ctrs[0]) * n_ctrs;

  fn_buffer = (struct gcov_fn_buffer *)malloc (len);

  if (!fn_buffer)

    goto fail;

  fn_buffer->next = 0;

  fn_buffer->fn_ix = fn_ix;

  fn_buffer->info.ident = gcov_read_unsigned ();

  fn_buffer->info.lineno_checksum = gcov_read_unsigned ();

  fn_buffer->info.cfg_checksum = gcov_read_unsigned ();

  for (n_ctrs = ix = 0; ix != GCOV_COUNTERS; ix++)

    {

      gcov_unsigned_t length;

      gcov_type *values;

      if (!gi_ptr->merge[ix])

        continue;

      if (gcov_read_unsigned () != GCOV_TAG_FOR_COUNTER (ix))

        {

          len = 0;

          goto fail;

        }

      length = GCOV_TAG_COUNTER_NUM (gcov_read_unsigned ());

      len = length * sizeof (gcov_type);

      values = (gcov_type *)malloc (len);

      if (!values)

        goto fail;

      fn_buffer->info.ctrs[n_ctrs].num = length;

      fn_buffer->info.ctrs[n_ctrs].values = values;

      while (length--)

        *values++ = gcov_read_counter ();

      n_ctrs++;

    }

  *end_ptr = fn_buffer;

  return &fn_buffer->next;

 fail:

  fprintf (stderr, "profiling:%s:Function %u %s %u \n", filename, fn_ix,

           len ? "cannot allocate" : "counter mismatch", len ? len : ix);

  return (struct gcov_fn_buffer **)free_fn_data (gi_ptr, fn_buffer, ix);

}

/* Add an unsigned value to the current crc */

static gcov_unsigned_t

crc32_unsigned (gcov_unsigned_t crc32, gcov_unsigned_t value)

{

  unsigned ix;

  for (ix = 32; ix--; value <<= 1)

    {

      unsigned feedback;

      feedback = (value ^ crc32) & 0x80000000 ? 0x04c11db7 : 0;

      crc32 <<= 1;

      crc32 ^= feedback;

    }

  return crc32;

}

/* Check if VERSION of the info block PTR matches libgcov one.

   Return 1 on success, or zero in case of versions mismatch.

   If FILENAME is not NULL, its value used for reporting purposes

   instead of value from the info block.  */

static int

gcov_version (struct gcov_info *ptr, gcov_unsigned_t version,

              const char *filename)

{

  if (version != GCOV_VERSION)

    {

      char v[4], e[4];

      GCOV_UNSIGNED2STRING (v, version);

      GCOV_UNSIGNED2STRING (e, GCOV_VERSION);

      fprintf (stderr,

               "profiling:%s:Version mismatch - expected %.4s got %.4s\n",

               filename? filename : ptr->filename, e, v);

      return 0;

    }

  return 1;

}

/* Dump the coverage counts. We merge with existing counts when

   possible, to avoid growing the .da files ad infinitum. We use this

   program's checksum to make sure we only accumulate whole program

   statistics to the correct summary. An object file might be embedded

   in two separate programs, and we must keep the two program

   summaries separate.  */

static void

gcov_exit (void)

{

  struct gcov_info *gi_ptr;

  const struct gcov_fn_info *gfi_ptr;

  struct gcov_summary this_prg; /* summary for program.  */

  struct gcov_summary all_prg;  /* summary for all instances of program.  */

  struct gcov_ctr_summary *cs_ptr;

  const struct gcov_ctr_info *ci_ptr;

  unsigned t_ix;

  int f_ix;

  gcov_unsigned_t c_num;

  const char *gcov_prefix;

  int gcov_prefix_strip = 0;

  size_t prefix_length;

  char *gi_filename, *gi_filename_up;

  gcov_unsigned_t crc32 = 0;

  memset (&all_prg, 0, sizeof (all_prg));

  /* Find the totals for this execution.  */

  memset (&this_prg, 0, sizeof (this_prg));

  for (gi_ptr = gcov_list; gi_ptr; gi_ptr = gi_ptr->next)

    {

      crc32 = crc32_unsigned (crc32, gi_ptr->stamp);

      crc32 = crc32_unsigned (crc32, gi_ptr->n_functions);

      for (f_ix = 0; (unsigned)f_ix != gi_ptr->n_functions; f_ix++)

        {

          gfi_ptr = gi_ptr->functions[f_ix];

          if (gfi_ptr && gfi_ptr->key != gi_ptr)

            gfi_ptr = 0;

          crc32 = crc32_unsigned (crc32, gfi_ptr ? gfi_ptr->cfg_checksum : 0);

          crc32 = crc32_unsigned (crc32,

                                  gfi_ptr ? gfi_ptr->lineno_checksum : 0);

          if (!gfi_ptr)

            continue;

          ci_ptr = gfi_ptr->ctrs;

          for (t_ix = 0; t_ix != GCOV_COUNTERS_SUMMABLE; t_ix++)

            {

              if (!gi_ptr->merge[t_ix])

                continue;

              cs_ptr = &this_prg.ctrs[t_ix];

              cs_ptr->num += ci_ptr->num;

              crc32 = crc32_unsigned (crc32, ci_ptr->num);

              for (c_num = 0; c_num < ci_ptr->num; c_num++)

                {

                  cs_ptr->sum_all += ci_ptr->values[c_num];

                  if (cs_ptr->run_max < ci_ptr->values[c_num])

                    cs_ptr->run_max = ci_ptr->values[c_num];

                }

              ci_ptr++;

            }

        }

    }

  {

    /* Check if the level of dirs to strip off specified. */

    char *tmp = getenv("GCOV_PREFIX_STRIP");

    if (tmp)

      {

        gcov_prefix_strip = atoi (tmp);

        /* Do not consider negative values. */

        if (gcov_prefix_strip < 0)

          gcov_prefix_strip = 0;

      }

  }

  /* Get file name relocation prefix.  Non-absolute values are ignored. */

  gcov_prefix = getenv("GCOV_PREFIX");

  if (gcov_prefix)

    {

      prefix_length = strlen(gcov_prefix);

      /* Remove an unnecessary trailing '/' */

      if (IS_DIR_SEPARATOR (gcov_prefix[prefix_length - 1]))

        prefix_length--;

    }

  else

    prefix_length = 0;

  /* If no prefix was specified and a prefix stip, then we assume

     relative.  */

  if (gcov_prefix_strip != 0 && prefix_length == 0)

    {

      gcov_prefix = ".";

      prefix_length = 1;

    }

  /* Allocate and initialize the filename scratch space plus one.  */

  gi_filename = (char *) alloca (prefix_length + gcov_max_filename + 2);

  if (prefix_length)

    memcpy (gi_filename, gcov_prefix, prefix_length);

  gi_filename_up = gi_filename + prefix_length;

  /* Now merge each file.  */

  for (gi_ptr = gcov_list; gi_ptr; gi_ptr = gi_ptr->next)

    {

      unsigned n_counts;

      struct gcov_summary prg; /* summary for this object over all

                                  program.  */

      struct gcov_ctr_summary *cs_prg, *cs_tprg, *cs_all;

      int error = 0;

      gcov_unsigned_t tag, length;

      gcov_position_t summary_pos = 0;

      gcov_position_t eof_pos = 0;

      const char *fname, *s;

      struct gcov_fn_buffer *fn_buffer = 0;

      struct gcov_fn_buffer **fn_tail = &fn_buffer;

      fname = gi_ptr->filename;

      /* Avoid to add multiple drive letters into combined path.  */

      if (prefix_length != 0 && HAS_DRIVE_SPEC(fname))

        fname += 2;

      /* Build relocated filename, stripping off leading

         directories from the initial filename if requested. */

      if (gcov_prefix_strip > 0)

        {

          int level = 0;

          s = fname;

          if (IS_DIR_SEPARATOR(*s))

            ++s;

          /* Skip selected directory levels. */

          for (; (*s != '\0') && (level < gcov_prefix_strip); s++)

            if (IS_DIR_SEPARATOR(*s))

              {

                fname = s;

                level++;

              }

        }

      /* Update complete filename with stripped original. */

      if (prefix_length != 0 && !IS_DIR_SEPARATOR (*fname))

        {

          /* If prefix is given, add directory separator.  */

          strcpy (gi_filename_up, "/");

          strcpy (gi_filename_up + 1, fname);

        }

      else

        strcpy (gi_filename_up, fname);

      if (!gcov_open (gi_filename))

        {

          /* Open failed likely due to missed directory.

             Create directory and retry to open file. */

          if (create_file_directory (gi_filename))

            {

              fprintf (stderr, "profiling:%s:Skip\n", gi_filename);

              continue;

            }

          if (!gcov_open (gi_filename))

            {

              fprintf (stderr, "profiling:%s:Cannot open\n", gi_filename);

              continue;

            }

        }

      tag = gcov_read_unsigned ();

      if (tag)

        {

          /* Merge data from file.  */

          if (tag != GCOV_DATA_MAGIC)

            {

              fprintf (stderr, "profiling:%s:Not a gcov data file\n",

                       gi_filename);

              goto read_fatal;

            }

          length = gcov_read_unsigned ();

          if (!gcov_version (gi_ptr, length, gi_filename))

            goto read_fatal;

          length = gcov_read_unsigned ();

          if (length != gi_ptr->stamp)

            /* Read from a different compilation. Overwrite the file.  */

            goto rewrite;

          /* Look for program summary.  */

          for (f_ix = 0;;)

            {

              struct gcov_summary tmp;

              eof_pos = gcov_position ();

              tag = gcov_read_unsigned ();

              if (tag != GCOV_TAG_PROGRAM_SUMMARY)

                break;

              f_ix--;

              length = gcov_read_unsigned ();

              if (length != GCOV_TAG_SUMMARY_LENGTH)

                goto read_mismatch;

              gcov_read_summary (&tmp);

              if ((error = gcov_is_error ()))

                goto read_error;

              if (summary_pos || tmp.checksum != crc32)

                goto next_summary;

              for (t_ix = 0; t_ix != GCOV_COUNTERS_SUMMABLE; t_ix++)

                if (tmp.ctrs[t_ix].num != this_prg.ctrs[t_ix].num)

                  goto next_summary;

              prg = tmp;

              summary_pos = eof_pos;

            next_summary:;

            }

          /* Merge execution counts for each function.  */

          for (f_ix = 0; (unsigned)f_ix != gi_ptr->n_functions;

               f_ix++, tag = gcov_read_unsigned ())

            {

              gfi_ptr = gi_ptr->functions[f_ix];

              if (tag != GCOV_TAG_FUNCTION)

                goto read_mismatch;

              length = gcov_read_unsigned ();

              if (!length)

                /* This function did not appear in the other program.

                   We have nothing to merge.  */

                continue;

              if (length != GCOV_TAG_FUNCTION_LENGTH)

                goto read_mismatch;

              if (!gfi_ptr || gfi_ptr->key != gi_ptr)

                {

                  /* This function appears in the other program.  We

                     need to buffer the information in order to write

                     it back out -- we'll be inserting data before

                     this point, so cannot simply keep the data in the

                     file.  */

                  fn_tail = buffer_fn_data (gi_filename,

                                            gi_ptr, fn_tail, f_ix);

                  if (!fn_tail)

                    goto read_mismatch;

                  continue;

                }

              length = gcov_read_unsigned ();

              if (length != gfi_ptr->ident)

                goto read_mismatch;

              length = gcov_read_unsigned ();

              if (length != gfi_ptr->lineno_checksum)

                goto read_mismatch;

              length = gcov_read_unsigned ();

              if (length != gfi_ptr->cfg_checksum)

                goto read_mismatch;

              ci_ptr = gfi_ptr->ctrs;

              for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++)

                {

                  gcov_merge_fn merge = gi_ptr->merge[t_ix];

                  if (!merge)

                    continue;

                  tag = gcov_read_unsigned ();

                  length = gcov_read_unsigned ();

                  if (tag != GCOV_TAG_FOR_COUNTER (t_ix)

                      || length != GCOV_TAG_COUNTER_LENGTH (ci_ptr->num))

                    goto read_mismatch;

                  (*merge) (ci_ptr->values, ci_ptr->num);

                  ci_ptr++;

                }

              if ((error = gcov_is_error ()))

                goto read_error;

            }

          if (tag)

            {

            read_mismatch:;

              fprintf (stderr, "profiling:%s:Merge mismatch for %s %u\n",

                       gi_filename, f_ix >= 0 ? "function" : "summary",

                       f_ix < 0 ? -1 - f_ix : f_ix);

              goto read_fatal;

            }

        }

      goto rewrite;

    read_error:;

      fprintf (stderr, "profiling:%s:%s merging\n", gi_filename,

               error < 0 ? "Overflow": "Error");

      goto read_fatal;

    rewrite:;

      gcov_rewrite ();

      if (!summary_pos)

        {

          memset (&prg, 0, sizeof (prg));

          summary_pos = eof_pos;

        }

      /* Merge the summaries.  */

      for (t_ix = 0; t_ix < GCOV_COUNTERS_SUMMABLE; t_ix++)

        {

          cs_prg = &prg.ctrs[t_ix];

          cs_tprg = &this_prg.ctrs[t_ix];

          cs_all = &all_prg.ctrs[t_ix];

          if (gi_ptr->merge[t_ix])

            {

              if (!cs_prg->runs++)

                cs_prg->num = cs_tprg->num;

              cs_prg->sum_all += cs_tprg->sum_all;

              if (cs_prg->run_max < cs_tprg->run_max)

                cs_prg->run_max = cs_tprg->run_max;

              cs_prg->sum_max += cs_tprg->run_max;

            }

          else if (cs_prg->runs)

            goto read_mismatch;

          if (!cs_all->runs && cs_prg->runs)

            memcpy (cs_all, cs_prg, sizeof (*cs_all));

          else if (!all_prg.checksum

                   && (!GCOV_LOCKED || cs_all->runs == cs_prg->runs)

                   && memcmp (cs_all, cs_prg, sizeof (*cs_all)))

            {

              fprintf (stderr, "profiling:%s:Invocation mismatch - some data files may have been removed%s\n",

                       gi_filename, GCOV_LOCKED

                       ? "" : " or concurrently updated without locking support");

              all_prg.checksum = ~0u;

            }

        }

      prg.checksum = crc32;

      /* Write out the data.  */

      if (!eof_pos)

        {

          gcov_write_tag_length (GCOV_DATA_MAGIC, GCOV_VERSION);

          gcov_write_unsigned (gi_ptr->stamp);

        }

      if (summary_pos)

        gcov_seek (summary_pos);

      /* Generate whole program statistics.  */

      gcov_write_summary (GCOV_TAG_PROGRAM_SUMMARY, &prg);

      if (summary_pos < eof_pos)

        gcov_seek (eof_pos);

      /* Write execution counts for each function.  */

      for (f_ix = 0; (unsigned)f_ix != gi_ptr->n_functions; f_ix++)

        {

          unsigned buffered = 0;

          if (fn_buffer && fn_buffer->fn_ix == (unsigned)f_ix)

            {

              /* Buffered data from another program.  */

              buffered = 1;

              gfi_ptr = &fn_buffer->info;

              length = GCOV_TAG_FUNCTION_LENGTH;

            }

          else

            {

              gfi_ptr = gi_ptr->functions[f_ix];

              if (gfi_ptr && gfi_ptr->key == gi_ptr)

                length = GCOV_TAG_FUNCTION_LENGTH;

              else

                length = 0;

            }

          gcov_write_tag_length (GCOV_TAG_FUNCTION, length);

          if (!length)

            continue;

          gcov_write_unsigned (gfi_ptr->ident);

          gcov_write_unsigned (gfi_ptr->lineno_checksum);

          gcov_write_unsigned (gfi_ptr->cfg_checksum);

          ci_ptr = gfi_ptr->ctrs;

          for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++)

            {

              if (!gi_ptr->merge[t_ix])

                continue;

              n_counts = ci_ptr->num;

              gcov_write_tag_length (GCOV_TAG_FOR_COUNTER (t_ix),

                                     GCOV_TAG_COUNTER_LENGTH (n_counts));

              gcov_type *c_ptr = ci_ptr->values;

              while (n_counts--)

                gcov_write_counter (*c_ptr++);

              ci_ptr++;

            }

          if (buffered)

            fn_buffer = free_fn_data (gi_ptr, fn_buffer, GCOV_COUNTERS);

        }

      gcov_write_unsigned (0);

    read_fatal:;

      while (fn_buffer)

        fn_buffer = free_fn_data (gi_ptr, fn_buffer, GCOV_COUNTERS);

      if ((error = gcov_close ()))

          fprintf (stderr, error  < 0 ?

                   "profiling:%s:Overflow writing\n" :