CbC/CbC_gcc: gcc/libgcov.c comparison

comparison gcc/libgcov.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	a06113de4d67
children	f6334be47118

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 /* Size of the longest file name. */
 static size_t gcov_max_filename = 0;
 #ifdef TARGET_POSIX_IO
 /* 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)
 {
 fprintf (stderr, "profiling:%s:Cannot create directory\n",
 		     filename);
 *s = sep;
 	    return -1;
 	  };
 	*s = sep;
 };
 return 0;
 }
 #endif
 /* 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;
 }
 gcov_prefix_strip = atoi (tmp);
 /* Do not consider negative values. */
 if (gcov_prefix_strip < 0)
 gcov_prefix_strip = 0;
 }
 prefix_length = strlen(gcov_prefix);
 /* Remove an unnecessary trailing '/' */
 if (IS_DIR_SEPARATOR (gcov_prefix[prefix_length - 1]))
 	prefix_length--;
 }
 else
 prefix_length = 0;
 /* Allocate and initialize the filename scratch space.  */
 gi_filename = (char *) alloca (prefix_length + gcov_max_filename + 1);
 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)
 {
 struct gcov_summary this_object;
 struct gcov_summary object, program;
 gcov_position_t summary_pos = 0;
 gcov_position_t eof_pos = 0;
 memset (&this_object, 0, sizeof (this_object));
 memset (&object, 0, sizeof (object));
 /* Build relocated filename, stripping off leading
 directories from the initial filename if requested. */
 if (gcov_prefix_strip > 0)
 {
 int level = 0;
 const char *fname = gi_ptr->filename;
 if (__alignof__ (struct gcov_fn_info) > sizeof (unsigned))
 	{
 	  fi_stride += __alignof__ (struct gcov_fn_info) - 1;
 	  fi_stride &= ~(__alignof__ (struct gcov_fn_info) - 1);
 	}
 if (!gcov_open (gi_filename))
 	{
 #ifdef TARGET_POSIX_IO
 	  /* Open failed likely due to missed directory.
 	     Create directory and retry to open file. */
 	  length = gcov_read_unsigned ();
 	  if (length != gi_ptr->stamp)
 	    /* Read from a different compilation. Overwrite the file.  */
 	    goto rewrite;
 	  /* Merge execution counts for each function.  */
 	  for (f_ix = 0; f_ix < gi_ptr->n_functions; f_ix++)
 	    {
 	      fi_ptr = (const struct gcov_fn_info *)
 		      ((const char *) gi_ptr->functions + f_ix * fi_stride);
 		{
 		  gcov_merge_fn merge;
 		  if (!((1 << t_ix) & gi_ptr->ctr_mask))
 		    continue;
 		  n_counts = fi_ptr->n_ctrs[c_ix];
 		  merge = gi_ptr->counts[c_ix].merge;
 		  tag = gcov_read_unsigned ();
 		  length = gcov_read_unsigned ();
 		  if (tag != GCOV_TAG_FOR_COUNTER (t_ix)
 		      || length != GCOV_TAG_COUNTER_LENGTH (n_counts))
 		    goto read_mismatch;
 	  f_ix = ~0u;
 	  /* Check program & object summary */
 	  while (1)
 	    {
 	      int is_program;
 	      eof_pos = gcov_position ();
 	      tag = gcov_read_unsigned ();
 	      if (!tag)
 		break;
 		  goto rewrite;
 		}
 	    }
 	}
 goto rewrite;
 read_error:;
 fprintf (stderr, error < 0 ? "profiling:%s:Overflow merging\n"
 	       : "profiling:%s:Error merging\n", gi_filename);
 read_fatal:;
 gcov_close ();
 continue;
 rewrite:;
 		goto read_mismatch;
 	      cs_obj->sum_all += cs_tobj->sum_all;
 	      if (cs_obj->run_max < cs_tobj->run_max)
 		cs_obj->run_max = cs_tobj->run_max;
 	      cs_obj->sum_max += cs_tobj->run_max;
 	      if (!cs_prg->runs++)
 		cs_prg->num = cs_tprg->num;
 	      else if (cs_prg->num != cs_tprg->num)
 		goto read_mismatch;
 	      cs_prg->sum_all += cs_tprg->sum_all;
 		cs_prg->run_max = cs_tprg->run_max;
 	      cs_prg->sum_max += cs_tprg->run_max;
 	    }
 	  else if (cs_obj->num || cs_prg->num)
 	    goto read_mismatch;
 	  if (!cs_all->runs && cs_prg->runs)
 	    memcpy (cs_all, cs_prg, sizeof (*cs_all));
 	  else if (!all.checksum
 		   && (!GCOV_LOCKED || cs_all->runs == cs_prg->runs)
 		   && memcmp (cs_all, cs_prg, sizeof (*cs_all)))
 		       gi_filename, GCOV_LOCKED
 		       ? "" : " or concurrent update without locking support");
 	      all.checksum = ~0u;
 	    }
 	}
 c_ix = 0;
 for (t_ix = 0; t_ix < GCOV_COUNTERS; t_ix++)
 	if ((1 << t_ix) & gi_ptr->ctr_mask)
 	  {
 	    values[c_ix] = gi_ptr->counts[c_ix].values;
 	    c_ix++;
 	  }
 program.checksum = gcov_crc32;
 /* Write out the data.  */
 gcov_write_tag_length (GCOV_DATA_MAGIC, GCOV_VERSION);
 gcov_write_unsigned (gi_ptr->stamp);
 /* Write execution counts for each function.  */
 for (f_ix = 0; f_ix < gi_ptr->n_functions; f_ix++)
 	{
 	  fi_ptr = (const struct gcov_fn_info *)
 		  ((const char *) gi_ptr->functions + f_ix * fi_stride);
 	      if (!((1 << t_ix) & gi_ptr->ctr_mask))
 		continue;
 	      n_counts = fi_ptr->n_ctrs[c_ix];
 	      gcov_write_tag_length (GCOV_TAG_FOR_COUNTER (t_ix),
 				     GCOV_TAG_COUNTER_LENGTH (n_counts));
 	      c_ptr = values[c_ix];
 	      while (n_counts--)
 		gcov_write_counter (*c_ptr++);
 size_t filename_length =  strlen(info->filename);
 /* Refresh the longest file name information */
 if (filename_length > gcov_max_filename)
 gcov_max_filename = filename_length;
 do
 	{
 	  unsigned ix;
 	  gcov_unsigned_t value = *ptr << 24;
 	      crc32 <<= 1;
 	      crc32 ^= feedback;
 	    }
 	}
 while (*ptr++);
 gcov_crc32 = crc32;
 if (!gcov_list)
 	atexit (gcov_exit);
 info->next = gcov_list;
 gcov_list = info;
 }
 info->version = 0;
 }
 gcov_exit ();
 for (gi_ptr = gcov_list; gi_ptr; gi_ptr = gi_ptr->next)
 {
 unsigned t_ix;
 const struct gcov_ctr_info *ci_ptr;
 for (t_ix = 0, ci_ptr = gi_ptr->counts; t_ix != GCOV_COUNTERS; t_ix++)
 	if ((1 << t_ix) & gi_ptr->ctr_mask)
 	  {
 	    memset (ci_ptr->values, 0, sizeof (gcov_type) * ci_ptr->num);
 	    ci_ptr++;
 /* The profile merging function for choosing the most common value.
 It is given an array COUNTERS of N_COUNTERS old counters and it
 reads the same number of counters from the gcov file.  The counters
 are split into 3-tuples where the members of the tuple have
 meanings:
 -- the stored candidate on the most common value of the measured entity
 -- counter
 -- total number of evaluations of the value  */
 void
 __gcov_merge_single (gcov_type *counters, unsigned n_counters)
 /* The profile merging function for choosing the most common
 difference between two consecutive evaluations of the value.  It is
 given an array COUNTERS of N_COUNTERS old counters and it reads the
 same number of counters from the gcov file.  The counters are split
 into 4-tuples where the members of the tuple have meanings:
 -- the last value of the measured entity
 -- the stored candidate on the most common difference
 -- counter
 -- total number of evaluations of the value  */
 void
 __gcov_merge_delta (gcov_type *counters, unsigned n_counters)
 {
 unsigned i, n_measures;
-gcov_type last, value, counter, all;
+gcov_type value, counter, all;
 gcc_assert (!(n_counters % 4));
 n_measures = n_counters / 4;
 for (i = 0; i < n_measures; i++, counters += 4)
 {
-last = gcov_read_counter ();
+/* last = */ gcov_read_counter ();
 value = gcov_read_counter ();
 counter = gcov_read_counter ();
 all = gcov_read_counter ();
 if (counters[1] == value)
 #endif
 #ifdef L_gcov_indirect_call_profiler
 /* Tries to determine the most common value among its inputs. */
 void
 __gcov_indirect_call_profiler (gcov_type* counter, gcov_type value,
 			       void* cur_func, void* callee_func)
 {
 /* If the C++ virtual tables contain function descriptors then one
 function may have multiple descriptors and we need to dereference
 the descriptors to see if they point to the same function.  */

Mercurial > hg > CbC > CbC_gcc

comparison gcc/libgcov.c @ 55:77e2b8dfacca gcc-4.4.5