gcc-7.1.0gcc-7.1.0

1 files changed, 372 insertions, 69 deletions

diff --git a/libcpp/line-map.c b/libcpp/line-map.c
index 2e61895bb3..949489eb1a 100644
--- a/libcpp/line-map.c
+++ b/libcpp/line-map.c
@@ -1,5 +1,5 @@
 /* Map (unsigned int) keys to (source file, line, column) triples.
-   Copyright (C) 2001-2016 Free Software Foundation, Inc.
+   Copyright (C) 2001-2017 Free Software Foundation, Inc.
 
 This program is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
@@ -31,18 +31,6 @@ along with this program; see the file COPYING3.  If not see
    disabled).  */
 const unsigned int LINE_MAP_MAX_COLUMN_NUMBER = (1U << 12);
 
-/* Do not pack ranges if locations get higher than this.
-   If you change this, update:
-     gcc.dg/plugin/location_overflow_plugin.c
-     gcc.dg/plugin/location-overflow-test-*.c.  */
-const source_location LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES = 0x50000000;
-
-/* Do not track column numbers if locations get higher than this.
-   If you change this, update:
-     gcc.dg/plugin/location_overflow_plugin.c
-     gcc.dg/plugin/location-overflow-test-*.c.  */
-const source_location LINE_MAP_MAX_LOCATION_WITH_COLS = 0x60000000;
-
 /* Highest possible source location encoded within an ordinary or
    macro map.  */
 const source_location LINE_MAP_MAX_SOURCE_LOCATION = 0x70000000;
@@ -69,6 +57,14 @@ static source_location linemap_macro_loc_to_exp_point (struct line_maps *,
 extern unsigned num_expanded_macros_counter;
 extern unsigned num_macro_tokens_counter;
 
+/* Destructor for class line_maps.
+   Ensure non-GC-managed memory is released.  */
+
+line_maps::~line_maps ()
+{
+  htab_delete (location_adhoc_data_map.htab);
+}
+
 /* Hash function for location_adhoc_data hashtable.  */
 
 static hashval_t
@@ -102,7 +98,7 @@ location_adhoc_data_eq (const void *l1, const void *l2)
 static int
 location_adhoc_data_update (void **slot, void *data)
 {
-  *((char **) slot) += *((long long *) data);
+  *((char **) slot) += *((int64_t *) data);
   return 1;
 }
 
@@ -224,7 +220,7 @@ get_combined_adhoc_loc (struct line_maps *set,
 	  set->location_adhoc_data_map.allocated)
 	{
 	  char *orig_data = (char *) set->location_adhoc_data_map.data;
-	  long long offset;
+	  int64_t offset;
 	  /* Cast away extern "C" from the type of xrealloc.  */
 	  line_map_realloc reallocator = (set->reallocator
 					  ? set->reallocator
@@ -323,11 +319,26 @@ pure_location_p (line_maps *set, source_location loc)
   return true;
 }
 
-/* Finalize the location_adhoc_data structure.  */
-void
-location_adhoc_data_fini (struct line_maps *set)
+/* Given location LOC within SET, strip away any packed range information
+   or ad-hoc information.  */
+
+source_location
+get_pure_location (line_maps *set, source_location loc)
 {
-  htab_delete (set->location_adhoc_data_map.htab);
+  if (IS_ADHOC_LOC (loc))
+    loc
+      = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
+
+  if (loc >= LINEMAPS_MACRO_LOWEST_LOCATION (set))
+    return loc;
+
+  if (loc < RESERVED_LOCATION_COUNT)
+    return loc;
+
+  const line_map *map = linemap_lookup (set, loc);
+  const line_map_ordinary *ordmap = linemap_check_ordinary (map);
+
+  return loc & ~((1 << ordmap->m_range_bits) - 1);
 }
 
 /* Initialize a line map set.  */
@@ -741,7 +752,7 @@ linemap_line_start (struct line_maps *set, linenum_type to_line,
 	 single line we can sometimes just increase its column_bits instead. */
       if (line_delta < 0
 	  || last_line != ORDINARY_MAP_STARTING_LINE_NUMBER (map)
-	  || SOURCE_COLUMN (map, highest) >= (1U << column_bits)
+	  || SOURCE_COLUMN (map, highest) >= (1U << (column_bits - range_bits))
 	  || range_bits < map->m_range_bits)
 	map = linemap_check_ordinary
 	        (const_cast <line_map *>
@@ -805,8 +816,22 @@ linemap_position_for_column (struct line_maps *set, unsigned int to_column)
 	}
       else
 	{
+	  /* Otherwise, attempt to start a new line that can hold TO_COLUMN,
+	     with some space to spare.  This may or may not lead to a new
+	     linemap being created.  */
 	  line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set);
 	  r = linemap_line_start (set, SOURCE_LINE (map, r), to_column + 50);
+	  map = LINEMAPS_LAST_ORDINARY_MAP (set);
+	  if (map->m_column_and_range_bits == 0)
+	    {
+	      /* ...then the linemap has column-tracking disabled,
+		 presumably due to exceeding either
+		 LINE_MAP_MAX_LOCATION_WITH_COLS (overall) or
+		 LINE_MAP_MAX_COLUMN_NUMBER (within this line).
+		 Return the start of the linemap, which encodes column 0, for
+		 the whole line.  */
+	      return r;
+	    }
 	}
     }
   line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set);
@@ -894,7 +919,10 @@ linemap_position_for_loc_and_offset (struct line_maps *set,
     }
 
   column += column_offset;
-  if (linemap_assert_fails (column < (1u << map->m_column_and_range_bits)))
+
+  /* Bail out if the column is not representable within the existing
+     linemap.  */
+  if (column >= (1u << (map->m_column_and_range_bits - map->m_range_bits)))
     return loc;
 
   source_location r = 
@@ -1213,9 +1241,8 @@ linemap_location_in_system_header_p (struct line_maps *set,
   return false;
 }
 
-/* Return TRUE if LOCATION is a source code location of a token coming
-   from a macro replacement-list at a macro expansion point, FALSE
-   otherwise.  */
+/* Return TRUE if LOCATION is a source code location of a token that is part of
+   a macro expansion, FALSE otherwise.  */
 
 bool
 linemap_location_from_macro_expansion_p (const struct line_maps *set,
@@ -1560,6 +1587,37 @@ linemap_resolve_location (struct line_maps *set,
   return loc;
 }
 
+/* TRUE if LOCATION is a source code location of a token that is part of the
+   definition of a macro, FALSE otherwise.  */
+
+bool
+linemap_location_from_macro_definition_p (struct line_maps *set,
+					  source_location loc)
+{
+  if (IS_ADHOC_LOC (loc))
+    loc = get_location_from_adhoc_loc (set, loc);
+
+  if (!linemap_location_from_macro_expansion_p (set, loc))
+    return false;
+
+  while (true)
+    {
+      const struct line_map_macro *map
+	= linemap_check_macro (linemap_lookup (set, loc));
+
+      source_location s_loc
+	= linemap_macro_map_loc_unwind_toward_spelling (set, map, loc);
+      if (linemap_location_from_macro_expansion_p (set, s_loc))
+	loc = s_loc;
+      else
+	{
+	  source_location def_loc
+	    = linemap_macro_map_loc_to_def_point (map, loc);
+	  return s_loc == def_loc;
+	}
+    }
+}
+
 /* 
    Suppose that LOC is the virtual location of a token T coming from
    the expansion of a macro M.  This function then steps up to get the
@@ -1971,11 +2029,13 @@ source_range::intersects_line_p (const char *file, int line) const
 
 /* Construct a rich_location with location LOC as its initial range.  */
 
-rich_location::rich_location (line_maps */*set*/, source_location loc) :
-  m_num_ranges (0),
+rich_location::rich_location (line_maps *set, source_location loc) :
+  m_line_table (set),
+  m_ranges (),
   m_column_override (0),
   m_have_expanded_location (false),
-  m_num_fixit_hints (0)
+  m_fixit_hints (),
+  m_seen_impossible_fixit (false)
 {
   add_range (loc, true);
 }
@@ -1984,8 +2044,8 @@ rich_location::rich_location (line_maps */*set*/, source_location loc) :
 
 rich_location::~rich_location ()
 {
-  for (unsigned int i = 0; i < m_num_fixit_hints; i++)
-    delete m_fixit_hints[i];
+  for (unsigned int i = 0; i < m_fixit_hints.count (); i++)
+    delete get_fixit_hint (i);
 }
 
 /* Get location IDX within this rich_location.  */
@@ -1993,8 +2053,24 @@ rich_location::~rich_location ()
 source_location
 rich_location::get_loc (unsigned int idx) const
 {
-  linemap_assert (idx < m_num_ranges);
-  return m_ranges[idx].m_loc;
+  const location_range *locrange = get_range (idx);
+  return locrange->m_loc;
+}
+
+/* Get range IDX within this rich_location.  */
+
+const location_range *
+rich_location::get_range (unsigned int idx) const
+{
+  return &m_ranges[idx];
+}
+
+/* Mutable access to range IDX within this rich_location.  */
+
+location_range *
+rich_location::get_range (unsigned int idx)
+{
+  return &m_ranges[idx];
 }
 
 /* Expand location IDX within this rich_location.  */
@@ -2037,11 +2113,10 @@ rich_location::override_column (int column)
 void
 rich_location::add_range (source_location loc, bool show_caret_p)
 {
-  linemap_assert (m_num_ranges < MAX_RANGES);
-
-  location_range *range = &m_ranges[m_num_ranges++];
-  range->m_loc = loc;
-  range->m_show_caret_p = show_caret_p;
+  location_range range;
+  range.m_loc = loc;
+  range.m_show_caret_p = show_caret_p;
+  m_ranges.push (range);
 }
 
 /* Add or overwrite the location given by IDX, setting its location to LOC,
@@ -2061,35 +2136,109 @@ void
 rich_location::set_range (line_maps * /*set*/, unsigned int idx,
 			  source_location loc, bool show_caret_p)
 {
-  linemap_assert (idx < MAX_RANGES);
-
   /* We can either overwrite an existing range, or add one exactly
      on the end of the array.  */
-  linemap_assert (idx <= m_num_ranges);
+  linemap_assert (idx <= m_ranges.count ());
 
-  location_range *locrange = &m_ranges[idx];
-  locrange->m_loc = loc;
-  locrange->m_show_caret_p = show_caret_p;
-
-  /* Are we adding a range onto the end?  */
-  if (idx == m_num_ranges)
-    m_num_ranges = idx + 1;
+  if (idx == m_ranges.count ())
+    add_range (loc,  show_caret_p);
+  else
+    {
+      location_range *locrange = get_range (idx);
+      locrange->m_loc = loc;
+      locrange->m_show_caret_p = show_caret_p;
+    }
 
   if (idx == 0)
     /* Mark any cached value here as dirty.  */
     m_have_expanded_location = false;
 }
 
+/* Methods for adding insertion fix-it hints.  */
+
+/* Add a fixit-hint, suggesting insertion of NEW_CONTENT
+   immediately before the primary range's start location.  */
+
+void
+rich_location::add_fixit_insert_before (const char *new_content)
+{
+  add_fixit_insert_before (get_loc (), new_content);
+}
+
+/* Add a fixit-hint, suggesting insertion of NEW_CONTENT
+   immediately before the start of WHERE.  */
+
+void
+rich_location::add_fixit_insert_before (source_location where,
+					const char *new_content)
+{
+  source_location start = get_range_from_loc (m_line_table, where).m_start;
+
+  if (reject_impossible_fixit (start))
+    return;
+  /* We do not yet support newlines within fix-it hints.  */
+  if (strchr (new_content, '\n'))
+    {
+      stop_supporting_fixits ();
+      return;
+    }
+  add_fixit (new fixit_insert (start, new_content));
+}
+
 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
-   at WHERE.  */
+   immediately after the primary range's end-point.  */
 
 void
-rich_location::add_fixit_insert (source_location where,
-				 const char *new_content)
+rich_location::add_fixit_insert_after (const char *new_content)
 {
-  linemap_assert (m_num_fixit_hints < MAX_FIXIT_HINTS);
-  m_fixit_hints[m_num_fixit_hints++]
-    = new fixit_insert (where, new_content);
+  add_fixit_insert_after (get_loc (), new_content);
+}
+
+/* Add a fixit-hint, suggesting insertion of NEW_CONTENT
+   immediately after the end-point of WHERE.  */
+
+void
+rich_location::add_fixit_insert_after (source_location where,
+				       const char *new_content)
+{
+  source_location finish = get_range_from_loc (m_line_table, where).m_finish;
+
+  if (reject_impossible_fixit (finish))
+    return;
+
+  source_location next_loc
+    = linemap_position_for_loc_and_offset (m_line_table, finish, 1);
+
+  /* linemap_position_for_loc_and_offset can fail, if so, it returns
+     its input value.  */
+  if (next_loc == finish)
+    {
+      stop_supporting_fixits ();
+      return;
+    }
+
+  add_fixit (new fixit_insert (next_loc, new_content));
+}
+
+/* Methods for adding removal fix-it hints.  */
+
+/* Add a fixit-hint, suggesting removal of the content covered
+   by range 0.  */
+
+void
+rich_location::add_fixit_remove ()
+{
+  add_fixit_remove (get_loc ());
+}
+
+/* Add a fixit-hint, suggesting removal of the content between
+   the start and finish of WHERE.  */
+
+void
+rich_location::add_fixit_remove (source_location where)
+{
+  source_range range = get_range_from_loc (m_line_table, where);
+  add_fixit_remove (range);
 }
 
 /* Add a fixit-hint, suggesting removal of the content at
@@ -2098,8 +2247,67 @@ rich_location::add_fixit_insert (source_location where,
 void
 rich_location::add_fixit_remove (source_range src_range)
 {
-  linemap_assert (m_num_fixit_hints < MAX_FIXIT_HINTS);
-  m_fixit_hints[m_num_fixit_hints++] = new fixit_remove (src_range);
+  add_fixit_replace (src_range, "");
+}
+
+/* Return true iff A is in the column directly before B, on the
+   same line of the same source file.  */
+
+static bool
+column_before_p (line_maps *set, source_location a, source_location b)
+{
+  if (IS_ADHOC_LOC (a))
+    a = get_location_from_adhoc_loc (set, a);
+  if (IS_ADHOC_LOC (b))
+    b = get_location_from_adhoc_loc (set, b);
+
+  /* They must both be in ordinary maps.  */
+  const struct line_map *linemap_a = linemap_lookup (set, a);
+  if (linemap_macro_expansion_map_p (linemap_a))
+    return false;
+  const struct line_map *linemap_b = linemap_lookup (set, b);
+  if (linemap_macro_expansion_map_p (linemap_b))
+    return false;
+
+  /* To be on the same line, they must be in the same ordinary map.  */
+  if (linemap_a != linemap_b)
+    return false;
+
+  linenum_type line_a
+    = SOURCE_LINE (linemap_check_ordinary (linemap_a), a);
+  linenum_type line_b
+    = SOURCE_LINE (linemap_check_ordinary (linemap_b), b);
+  if (line_a != line_b)
+    return false;
+
+  linenum_type column_a
+    = SOURCE_COLUMN (linemap_check_ordinary (linemap_a), a);
+  linenum_type column_b
+    = SOURCE_COLUMN (linemap_check_ordinary (linemap_b), b);
+
+  return column_b == column_a + 1;
+}
+
+/* Add a fixit-hint, suggesting replacement of the content covered
+   by range 0 with NEW_CONTENT.  */
+
+void
+rich_location::add_fixit_replace (const char *new_content)
+{
+  add_fixit_replace (get_loc (), new_content);
+}
+
+/* Methods for adding "replace" fix-it hints.  */
+
+/* Add a fixit-hint, suggesting replacement of the content between
+   the start and finish of WHERE with NEW_CONTENT.  */
+
+void
+rich_location::add_fixit_replace (source_location where,
+				  const char *new_content)
+{
+  source_range range = get_range_from_loc (m_line_table, where);
+  add_fixit_replace (range, new_content);
 }
 
 /* Add a fixit-hint, suggesting replacement of the content at
@@ -2109,9 +2317,87 @@ void
 rich_location::add_fixit_replace (source_range src_range,
 				  const char *new_content)
 {
-  linemap_assert (m_num_fixit_hints < MAX_FIXIT_HINTS);
-  m_fixit_hints[m_num_fixit_hints++]
-    = new fixit_replace (src_range, new_content);
+  src_range.m_start = get_pure_location (m_line_table, src_range.m_start);
+  src_range.m_finish = get_pure_location (m_line_table, src_range.m_finish);
+
+  if (reject_impossible_fixit (src_range.m_start))
+    return;
+  if (reject_impossible_fixit (src_range.m_finish))
+    return;
+
+  /* We do not yet support newlines within fix-it hints.  */
+  if (strchr (new_content, '\n'))
+    {
+      stop_supporting_fixits ();
+      return;
+    }
+
+  /* Consolidate neighboring fixits.  */
+  fixit_hint *prev = get_last_fixit_hint ();
+  if (prev)
+    if (prev->maybe_append_replace (m_line_table, src_range, new_content))
+      return;
+
+  add_fixit (new fixit_replace (src_range, new_content));
+}
+
+/* Get the last fix-it hint within this rich_location, or NULL if none.  */
+
+fixit_hint *
+rich_location::get_last_fixit_hint () const
+{
+  if (m_fixit_hints.count () > 0)
+    return get_fixit_hint (m_fixit_hints.count () - 1);
+  else
+    return NULL;
+}
+
+/* If WHERE is an "awkward" location, then mark this rich_location as not
+   supporting fixits, purging any thay were already added, and return true.
+
+   Otherwise (the common case), return false.  */
+
+bool
+rich_location::reject_impossible_fixit (source_location where)
+{
+  /* Fix-its within a rich_location should either all be suggested, or
+     none of them should be suggested.
+     Once we've rejected a fixit, we reject any more, even those
+     with reasonable locations.  */
+  if (m_seen_impossible_fixit)
+    return true;
+
+  if (where <= LINE_MAP_MAX_LOCATION_WITH_COLS)
+    /* WHERE is a reasonable location for a fix-it; don't reject it.  */
+    return false;
+
+  /* Otherwise we have an attempt to add a fix-it with an "awkward"
+     location: either one that we can't obtain column information
+     for (within an ordinary map), or one within a macro expansion.  */
+  stop_supporting_fixits ();
+  return true;
+}
+
+/* Mark this rich_location as not supporting fixits, purging any that were
+   already added.  */
+
+void
+rich_location::stop_supporting_fixits ()
+{
+  m_seen_impossible_fixit = true;
+
+  /* Purge the rich_location of any fix-its that were already added. */
+  for (unsigned int i = 0; i < m_fixit_hints.count (); i++)
+    delete get_fixit_hint (i);
+  m_fixit_hints.truncate (0);
+}
+
+/* Add HINT to the fix-it hints in this rich_location.  */
+
+void
+rich_location::add_fixit (fixit_hint *hint)
+{
+  m_fixit_hints.push (hint);
 }
 
 /* class fixit_insert.  */
@@ -2132,7 +2418,7 @@ fixit_insert::~fixit_insert ()
 /* Implementation of fixit_hint::affects_line_p for fixit_insert.  */
 
 bool
-fixit_insert::affects_line_p (const char *file, int line)
+fixit_insert::affects_line_p (const char *file, int line) const
 {
   expanded_location exploc
     = linemap_client_expand_location_to_spelling_point (m_where);
@@ -2142,19 +2428,13 @@ fixit_insert::affects_line_p (const char *file, int line)
   return false;
 }
 
-/* class fixit_remove.  */
-
-fixit_remove::fixit_remove (source_range src_range)
-: m_src_range (src_range)
-{
-}
-
-/* Implementation of fixit_hint::affects_line_p for fixit_remove.  */
+/* Implementation of maybe_append_replace for fixit_insert.  Reject
+   the attempt to consolidate fix-its.  */
 
 bool
-fixit_remove::affects_line_p (const char *file, int line)
+fixit_insert::maybe_append_replace (line_maps *, source_range, const char *)
 {
-  return m_src_range.intersects_line_p (file, line);
+  return false;
 }
 
 /* class fixit_replace.  */
@@ -2175,7 +2455,30 @@ fixit_replace::~fixit_replace ()
 /* Implementation of fixit_hint::affects_line_p for fixit_replace.  */
 
 bool
-fixit_replace::affects_line_p (const char *file, int line)
+fixit_replace::affects_line_p (const char *file, int line) const
 {
   return m_src_range.intersects_line_p (file, line);
 }
+
+/* Implementation of maybe_append_replace for fixit_replace.  If
+   possible, merge the new replacement into this one and return true.
+   Otherwise return false.  */
+
+bool
+fixit_replace::maybe_append_replace (line_maps *set,
+				     source_range src_range,
+				     const char *new_content)
+{
+  /* Does SRC_RANGE start immediately after this one finishes?  */
+  if (!column_before_p (set, m_src_range.m_finish, src_range.m_start))
+    return false;
+
+  /* We have neighboring replacements; merge them.  */
+  m_src_range.m_finish = src_range.m_finish;
+  size_t extra_len = strlen (new_content);
+  m_bytes = (char *)xrealloc (m_bytes, m_len + extra_len + 1);
+  memcpy (m_bytes + m_len, new_content, extra_len);
+  m_len += extra_len;
+  m_bytes[m_len] = '\0';
+  return true;
+}