Default allocator

	Default allocator
	libcpp/
	* include/line-map.h (line_maps): Document default allocator.
	* line-map.c (linemap_init): Set default allocator.
	(new_linemap): No need to set default here.  Simplify data flow.

From-SVN: r262520

diff --git a/ChangeLog.name-lookup b/ChangeLog.name-lookup
index 03bb9c69848140195b9ee300f3ab95aa6f1e3971..6b06b0e69f607de5ff362e624976b2bb83d89a53 100644 (file)
--- a/ChangeLog.name-lookup
+++ b/ChangeLog.name-lookup
@@ -1,3 +1,11 @@
+2018-07-09  Nathan Sidwell  <nathan@acm.org>
+
+       Default allocator
+       libcpp/
+       * include/line-map.h (line_maps): Document default allocator.
+       * line-map.c (linemap_init): Set default allocator.
+       (new_linemap): No need to set default here.  Simplify data flow.
+
 2018-07-06  Nathan Sidwell  <nathan@acm.org>
 
        Hide NT_MACRO

diff --git a/libcpp/include/line-map.h b/libcpp/include/line-map.h
index ba1750d3cf1bb3535bd1837dcf01cd2033be6cc1..80c3a1b5b1e5aba2575d5f8ed0bf3071714a7aaa 100644 (file)
--- a/libcpp/include/line-map.h
+++ b/libcpp/include/line-map.h
@@ -788,8 +788,7 @@ struct GTY(()) line_maps {
      may require allocating a new line_map.  */
   unsigned int max_column_hint;
 
-  /* If non-null, the allocator to use when resizing 'maps'.  If null,
-     xrealloc is used.  */
+  /* The allocator to use when resizing 'maps', defaults to xrealloc.  */
   line_map_realloc reallocator;
 
   /* The allocators' function used to know the actual size it

diff --git a/libcpp/line-map.c b/libcpp/line-map.c
index 105102268cca6d193bfc09695d95e34863cfe1ac..3b5045091b7e7ad3fa3225d005b239fc8a75f397 100644 (file)
--- a/libcpp/line-map.c
+++ b/libcpp/line-map.c
@@ -346,6 +346,8 @@ linemap_init (struct line_maps *set,
 #else
   new (set) line_maps();
 #endif
+  /* Set default allocator.  */
+  set->reallocator = (line_map_realloc) xrealloc;
   set->highest_location = RESERVED_LOCATION_COUNT - 1;
   set->highest_line = RESERVED_LOCATION_COUNT - 1;
   set->location_adhoc_data_map.htab =
@@ -376,81 +378,58 @@ linemap_check_files_exited (struct line_maps *set)
 static struct line_map *
 new_linemap (struct line_maps *set,  source_location start_location)
 {
-  struct line_map *result;
-  bool macro_map_p = start_location >= LINE_MAP_MAX_LOCATION;
+  bool macro_p = start_location >= LINE_MAP_MAX_LOCATION;
+  unsigned alloc = LINEMAPS_ALLOCATED (set, macro_p);
+  unsigned used = LINEMAPS_USED (set, macro_p);
 
-  if (LINEMAPS_USED (set, macro_map_p) == LINEMAPS_ALLOCATED (set, macro_map_p))
+  if (used == alloc)
     {
-      /* We ran out of allocated line maps. Let's allocate more.  */
-      size_t alloc_size;
-
-      /* Cast away extern "C" from the type of xrealloc.  */
-      line_map_realloc reallocator = (set->reallocator
-                                     ? set->reallocator
-                                     : (line_map_realloc) xrealloc);
-      line_map_round_alloc_size_func round_alloc_size =
-       set->round_alloc_size;
-
-      size_t map_size = (macro_map_p
-                        ? sizeof (line_map_macro)
-                        : sizeof (line_map_ordinary));
+      /* We need more space!  */
+      if (!alloc)
+       alloc = 128;
+      alloc *= 2;
+
+      size_t map_size;
+      void *buffer;
+      if (macro_p)
+       {
+         map_size = sizeof (line_map_macro);
+         buffer = set->info_macro.maps;
+       }
+      else
+       {
+         map_size = sizeof (line_map_ordinary);
+         buffer = set->info_ordinary.maps;
+       }
 
       /* We are going to execute some dance to try to reduce the
         overhead of the memory allocator, in case we are using the
         ggc-page.c one.
         
         The actual size of memory we are going to get back from the
-        allocator is the smallest power of 2 that is greater than the
-        size we requested.  So let's consider that size then.  */
-
-      alloc_size =
-       (2 * LINEMAPS_ALLOCATED (set, macro_map_p) +  256)
-       * map_size;
-
-      /* Get the actual size of memory that is going to be allocated
-        by the allocator.  */
-      alloc_size = round_alloc_size (alloc_size);
+        allocator may well be larger than what we ask for.  Use this
+        hook to find what that size is.  */
+      size_t alloc_size = set->round_alloc_size (alloc * map_size);
 
       /* Now alloc_size contains the exact memory size we would get if
         we have asked for the initial alloc_size amount of memory.
         Let's get back to the number of macro map that amounts
         to.  */
-      LINEMAPS_ALLOCATED (set, macro_map_p) =
-       alloc_size / map_size;
-
-      /* And now let's really do the re-allocation.  */
-      if (macro_map_p)
-       {
-         set->info_macro.maps
-           = (line_map_macro *) (*reallocator) (set->info_macro.maps,
-                                                (LINEMAPS_ALLOCATED (set, macro_map_p)
-                                                 * map_size));
-         result = &set->info_macro.maps[LINEMAPS_USED (set, macro_map_p)];
-       }
-      else
-       {
-         set->info_ordinary.maps =
-           (line_map_ordinary *) (*reallocator) (set->info_ordinary.maps,
-                                                 (LINEMAPS_ALLOCATED (set, macro_map_p)
-                                                  * map_size));
-         result = &set->info_ordinary.maps[LINEMAPS_USED (set, macro_map_p)];
-       }
-      memset (result, 0,
-             ((LINEMAPS_ALLOCATED (set, macro_map_p)
-               - LINEMAPS_USED (set, macro_map_p))
-              * map_size));
-    }
-  else
-    {
-      if (macro_map_p)
-       result = &set->info_macro.maps[LINEMAPS_USED (set, macro_map_p)];
+      unsigned num_maps = alloc_size / map_size;
+      buffer = set->reallocator (buffer, num_maps * map_size);
+      memset ((char *)buffer + used * map_size, 0, (num_maps - used) * map_size);
+      if (macro_p)
+       set->info_macro.maps = (line_map_macro *)buffer;
       else
-       result = &set->info_ordinary.maps[LINEMAPS_USED (set, macro_map_p)];
+       set->info_ordinary.maps = (line_map_ordinary *)buffer;
+      LINEMAPS_ALLOCATED (set, macro_p) = num_maps;
     }
 
-  result->start_location = start_location;
+  line_map *result = (macro_p ? (line_map *)&set->info_macro.maps[used]
+                     : (line_map *)&set->info_ordinary.maps[used]);
+  LINEMAPS_USED (set, macro_p)++;
 
-  LINEMAPS_USED (set, macro_map_p)++;
+  result->start_location = start_location;
 
   return result;
 }