gcc/vec.c

   1 /* Vector API for GNU compiler.
   2    Copyright (C) 2004-2015 Free Software Foundation, Inc.
   3    Contributed by Nathan Sidwell <nathan@codesourcery.com>
   4    Re-implemented in C++ by Diego Novillo <dnovillo@google.com>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 /* This file is compiled twice: once for the generator programs
  23    once for the compiler.  */
  24 #ifdef GENERATOR_FILE
  25 #include "bconfig.h"
  26 #else
  27 #include "config.h"
  28 #endif
  29
  30 #include "system.h"
  31 #include "coretypes.h"
  32 #include "diagnostic-core.h"
  33 #include "hash-table.h"
  34
  35 /* vNULL is an empty type with a template cast operation that returns
  36    a zero-initialized vec<T, A, L> instance.  Use this when you want
  37    to assign nil values to new vec instances or pass a nil vector as
  38    a function call argument.
  39
  40    We use this technique because vec<T, A, L> must be PODs (they are
  41    stored in unions and passed in vararg functions), this means that
  42    they cannot have ctors/dtors.  */
  43 vnull vNULL;
  44
  45 /* Vector memory usage.  */
  46 struct vec_usage: public mem_usage
  47 {
  48   /* Default constructor.  */
  49   vec_usage (): m_items (0), m_items_peak (0) {}
  50
  51   /* Constructor.  */
  52   vec_usage (size_t allocated, size_t times, size_t peak,
  53              size_t items, size_t items_peak)
  54     : mem_usage (allocated, times, peak),
  55     m_items (items), m_items_peak (items_peak) {}
  56
  57   /* Comparison operator.  */
  58   inline bool
  59   operator< (const vec_usage &second) const
  60   {
  61     return (m_allocated == second.m_allocated ?
  62             (m_peak == second.m_peak ? m_times < second.m_times
  63              : m_peak < second.m_peak) : m_allocated < second.m_allocated);
  64   }
  65
  66   /* Sum the usage with SECOND usage.  */
  67   vec_usage
  68   operator+ (const vec_usage &second)
  69   {
  70     return vec_usage (m_allocated + second.m_allocated,
  71                       m_times + second.m_times,
  72                       m_peak + second.m_peak,
  73                       m_items + second.m_items,
  74                       m_items_peak + second.m_items_peak);
  75   }
  76
  77   /* Dump usage coupled to LOC location, where TOTAL is sum of all rows.  */
  78   inline void
  79   dump (mem_location *loc, mem_usage &total) const
  80   {
  81     char s[4096];
  82     sprintf (s, "%s:%i (%s)", loc->get_trimmed_filename (),
  83              loc->m_line, loc->m_function);
  84
  85     s[48] = '\0';
  86
  87     fprintf (stderr, "%-48s %10li:%4.1f%%%10li%10li:%4.1f%%%11li%11li\n", s,
  88              (long)m_allocated, m_allocated * 100.0 / total.m_allocated,
  89              (long)m_peak, (long)m_times, m_times * 100.0 / total.m_times,
  90              (long)m_items, (long)m_items_peak);
  91   }
  92
  93   /* Dump footer.  */
  94   inline void
  95   dump_footer ()
  96   {
  97     print_dash_line ();
  98     fprintf (stderr, "%s%55li%25li%17li\n", "Total", (long)m_allocated,
  99              (long)m_times, (long)m_items);
 100     print_dash_line ();
 101   }
 102
 103   /* Dump header with NAME.  */
 104   static inline void
 105   dump_header (const char *name)
 106   {
 107     fprintf (stderr, "%-48s %11s%15s%10s%17s%11s\n", name, "Leak", "Peak",
 108              "Times", "Leak items", "Peak items");
 109     print_dash_line ();
 110   }
 111
 112   /* Compare wrapper used by qsort method.  */
 113   static int
 114   compare (const void *first, const void *second)
 115   {
 116     typedef std::pair<mem_location *, vec_usage *> mem_pair_t;
 117
 118     const mem_pair_t f = *(const mem_pair_t *)first;
 119     const mem_pair_t s = *(const mem_pair_t *)second;
 120
 121     return (*f.second) < (*s.second);
 122   }
 123
 124   /* Current number of items allocated.  */
 125   size_t m_items;
 126   /* Peak value of number of allocated items.  */
 127   size_t m_items_peak;
 128 };
 129
 130 /* Vector memory description.  */
 131 static mem_alloc_description <vec_usage> vec_mem_desc;
 132
 133 /* Account the overhead.  */
 134
 135 void
 136 vec_prefix::register_overhead (void *ptr, size_t size, size_t elements
 137                                MEM_STAT_DECL)
 138 {
 139   vec_mem_desc.register_descriptor (ptr, VEC_ORIGIN, false
 140                                     FINAL_PASS_MEM_STAT);
 141   vec_usage *usage = vec_mem_desc.register_instance_overhead (size, ptr);
 142   usage->m_items += elements;
 143   if (usage->m_items_peak < usage->m_items)
 144     usage->m_items_peak = usage->m_items;
 145 }
 146
 147 /* Notice that the memory allocated for the vector has been freed.  */
 148
 149 void
 150 vec_prefix::release_overhead (void *ptr, size_t size, bool in_dtor
 151                               MEM_STAT_DECL)
 152 {
 153   if (!vec_mem_desc.contains_descriptor_for_instance (ptr))
 154     vec_mem_desc.register_descriptor (ptr, VEC_ORIGIN,
 155                                       false FINAL_PASS_MEM_STAT);
 156   vec_mem_desc.release_instance_overhead (ptr, size, in_dtor);
 157 }
 158
 159
 160 /* Calculate the number of slots to reserve a vector, making sure that
 161    it is of at least DESIRED size by growing ALLOC exponentially.  */
 162
 163 unsigned
 164 vec_prefix::calculate_allocation_1 (unsigned alloc, unsigned desired)
 165 {
 166   /* We must have run out of room.  */
 167   gcc_assert (alloc < desired);
 168
 169   /* Exponential growth. */
 170   if (!alloc)
 171     alloc = 4;
 172   else if (alloc < 16)
 173     /* Double when small.  */
 174     alloc = alloc * 2;
 175   else
 176     /* Grow slower when large.  */
 177     alloc = (alloc * 3 / 2);
 178
 179   /* If this is still too small, set it to the right size. */
 180   if (alloc < desired)
 181     alloc = desired;
 182   return alloc;
 183 }
 184
 185 /* Dump per-site memory statistics.  */
 186
 187 void
 188 dump_vec_loc_statistics (void)
 189 {
 190   vec_mem_desc.dump (VEC_ORIGIN);
 191 }