CbC/CbC_gcc: libcpp/line-map.c comparison

comparison libcpp/line-map.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Map (unsigned int) keys to (source file, line, column) triples.
-Copyright (C) 2001-2018 Free Software Foundation, Inc.
+Copyright (C) 2001-2020 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
 Free Software Foundation; either version 3, or (at your option) any
 later version.
 #include "line-map.h"
 #include "cpplib.h"
 #include "internal.h"
 #include "hashtab.h"
-static void trace_include (const struct line_maps *, const line_map_ordinary *);
+static void trace_include (const line_maps *, const line_map_ordinary *);
-static const line_map_ordinary * linemap_ordinary_map_lookup (struct line_maps *,
+static const line_map_ordinary * linemap_ordinary_map_lookup (const line_maps *,
-							      source_location);
+							      location_t);
-static const line_map_macro* linemap_macro_map_lookup (struct line_maps *,
+static const line_map_macro* linemap_macro_map_lookup (const line_maps *,
-						       source_location);
+						       location_t);
-static source_location linemap_macro_map_loc_to_def_point
+static location_t linemap_macro_map_loc_to_def_point
-(const line_map_macro *, source_location);
+(const line_map_macro *, location_t);
-static source_location linemap_macro_map_loc_to_exp_point
+static location_t linemap_macro_map_loc_to_exp_point
-(const line_map_macro *, source_location);
+(const line_map_macro *, location_t);
-static source_location linemap_macro_loc_to_spelling_point
+static location_t linemap_macro_loc_to_spelling_point
-(struct line_maps *, source_location, const line_map_ordinary **);
+(line_maps *, location_t, const line_map_ordinary **);
-static source_location linemap_macro_loc_to_def_point (struct line_maps *,
+static location_t linemap_macro_loc_to_def_point (line_maps *,
-						       source_location,
+						  location_t,
-						       const line_map_ordinary **);
+						  const line_map_ordinary **);
-static source_location linemap_macro_loc_to_exp_point (struct line_maps *,
+static location_t linemap_macro_loc_to_exp_point (line_maps *,
-						       source_location,
+						  location_t,
-						       const line_map_ordinary **);
+						  const line_map_ordinary **);
 /* Counters defined in macro.c.  */
 extern unsigned num_expanded_macros_counter;
 extern unsigned num_macro_tokens_counter;
 }
 /* Rebuild the hash table from the location adhoc data.  */
 void
-rebuild_location_adhoc_htab (struct line_maps *set)
+rebuild_location_adhoc_htab (line_maps *set)
 {
 unsigned i;
 set->location_adhoc_data_map.htab =
 htab_create (100, location_adhoc_data_hash, location_adhoc_data_eq, NULL);
 for (i = 0; i < set->location_adhoc_data_map.curr_loc; i++)
 		    set->location_adhoc_data_map.data + i, INSERT);
 }
 /* Helper function for get_combined_adhoc_loc.
 Can the given LOCUS + SRC_RANGE and DATA pointer be stored compactly
-within a source_location, without needing to use an ad-hoc location.  */
+within a location_t, without needing to use an ad-hoc location.  */
 static bool
-can_be_stored_compactly_p (struct line_maps *set,
+can_be_stored_compactly_p (line_maps *set,
-			   source_location locus,
+			   location_t locus,
 			   source_range src_range,
 			   void *data)
 {
 /* If there's an ad-hoc pointer, we can't store it directly in the
-source_location, we need the lookaside.  */
+location_t, we need the lookaside.  */
 if (data)
 return false;
 /* We only store ranges that begin at the locus and that are sufficiently
 "sane".  */
 if (locus >= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES)
 return false;
 /* All 3 locations must be within ordinary maps, typically, the same
 ordinary map.  */
-source_location lowest_macro_loc = LINEMAPS_MACRO_LOWEST_LOCATION (set);
+location_t lowest_macro_loc = LINEMAPS_MACRO_LOWEST_LOCATION (set);
 if (locus >= lowest_macro_loc)
 return false;
 if (src_range.m_start >= lowest_macro_loc)
 return false;
 if (src_range.m_finish >= lowest_macro_loc)
 return true;
 }
 /* Combine LOCUS and DATA to a combined adhoc loc.  */
-source_location
+location_t
-get_combined_adhoc_loc (struct line_maps *set,
+get_combined_adhoc_loc (line_maps *set,
-			source_location locus,
+			location_t locus,
 			source_range src_range,
 			void *data)
 {
 struct location_adhoc_data lb;
 struct location_adhoc_data **slot;
 if (IS_ADHOC_LOC (locus))
-locus
+locus = get_location_from_adhoc_loc (set, locus);
-= set->location_adhoc_data_map.data[locus & MAX_SOURCE_LOCATION].locus;
 if (locus == 0 && data == NULL)
 return 0;
 /* Any ordinary locations ought to be "pure" at this point: no
 compressed ranges.  */
 const line_map_ordinary *ordmap = linemap_check_ordinary (map);
 unsigned int int_diff = src_range.m_finish - src_range.m_start;
 unsigned int col_diff = (int_diff >> ordmap->m_range_bits);
 if (col_diff < (1U << ordmap->m_range_bits))
 	{
-	  source_location packed = locus | col_diff;
+	  location_t packed = locus | col_diff;
 	  set->num_optimized_ranges++;
 	  return packed;
 	}
 }
 }
 /* Return the data for the adhoc loc.  */
 void *
-get_data_from_adhoc_loc (struct line_maps *set, source_location loc)
+get_data_from_adhoc_loc (const class line_maps *set, location_t loc)
 {
 linemap_assert (IS_ADHOC_LOC (loc));
-return set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].data;
+return set->location_adhoc_data_map.data[loc & MAX_LOCATION_T].data;
 }
 /* Return the location for the adhoc loc.  */
-source_location
+location_t
-get_location_from_adhoc_loc (struct line_maps *set, source_location loc)
+get_location_from_adhoc_loc (const class line_maps *set, location_t loc)
 {
 linemap_assert (IS_ADHOC_LOC (loc));
-return set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
+return set->location_adhoc_data_map.data[loc & MAX_LOCATION_T].locus;
 }
 /* Return the source_range for adhoc location LOC.  */
 static source_range
-get_range_from_adhoc_loc (struct line_maps *set, source_location loc)
+get_range_from_adhoc_loc (const class line_maps *set, location_t loc)
 {
 linemap_assert (IS_ADHOC_LOC (loc));
-return set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].src_range;
+return set->location_adhoc_data_map.data[loc & MAX_LOCATION_T].src_range;
 }
 /* Get the source_range of location LOC, either from the ad-hoc
 lookaside table, or embedded inside LOC itself.  */
 source_range
-get_range_from_loc (struct line_maps *set,
+get_range_from_loc (line_maps *set,
-		    source_location loc)
+		    location_t loc)
 {
 if (IS_ADHOC_LOC (loc))
 return get_range_from_adhoc_loc (set, loc);
 /* For ordinary maps, extract packed range.  */
 /* Get whether location LOC is a "pure" location, or
 whether it is an ad-hoc location, or embeds range information.  */
 bool
-pure_location_p (line_maps *set, source_location loc)
+pure_location_p (line_maps *set, location_t loc)
 {
 if (IS_ADHOC_LOC (loc))
 return false;
 const line_map *map = linemap_lookup (set, loc);
 }
 /* Given location LOC within SET, strip away any packed range information
 or ad-hoc information.  */
-source_location
+location_t
-get_pure_location (line_maps *set, source_location loc)
+get_pure_location (line_maps *set, location_t loc)
 {
 if (IS_ADHOC_LOC (loc))
-loc
+loc = get_location_from_adhoc_loc (set, 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)
 }
 /* Initialize a line map set.  */
 void
-linemap_init (struct line_maps *set,
+linemap_init (line_maps *set,
-	      source_location builtin_location)
+	      location_t builtin_location)
 {
 #if __GNUC__ == 4 && __GNUC_MINOR__ == 2 && !defined (__clang__)
 /* PR33916, needed to fix PR82939.  */
-memset (set, 0, sizeof (struct line_maps));
+memset (set, 0, sizeof (line_maps));
 #else
 new (set) line_maps();
 #endif
 /* Set default reallocator (used for initial alloc too).  */
 set->reallocator = xrealloc;
 }
 /* Check for and warn about line_maps entered but not exited.  */
 void
-linemap_check_files_exited (struct line_maps *set)
+linemap_check_files_exited (line_maps *set)
 {
 /* Depending upon whether we are handling preprocessed input or
 not, this can be a user error or an ICE.  */
 for (const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set);
 ! MAIN_FILE_P (map);
 REASON is the reason of creating the map. It determines the type
 of map created (ordinary or macro map). Note that ordinary maps and
 macro maps are allocated in different memory location.  */
 static struct line_map *
-new_linemap (struct line_maps *set,  source_location start_location)
+new_linemap (line_maps *set,  location_t start_location)
 {
 bool macro_p = start_location >= LINE_MAP_MAX_LOCATION;
 unsigned num_maps_allocated = LINEMAPS_ALLOCATED (set, macro_p);
 unsigned num_maps_used = LINEMAPS_USED (set, macro_p);
 FROM_LINE should be monotonic increasing across calls to this
 function.  A call to this function can relocate the previous set of
 maps, so any stored line_map pointers should not be used.  */
 const struct line_map *
-linemap_add (struct line_maps *set, enum lc_reason reason,
+linemap_add (line_maps *set, enum lc_reason reason,
 	     unsigned int sysp, const char *to_file, linenum_type to_line)
 {
 /* Generate a start_location above the current highest_location.
 If possible, make the low range bits be zero.  */
-source_location start_location;
+location_t start_location;
 if (set->highest_location < LINE_MAP_MAX_LOCATION_WITH_COLS)
 {
 start_location = set->highest_location + (1 << set->default_range_bits);
 if (set->default_range_bits)
 	start_location &= ~((1 << set->default_range_bits) - 1);
 /* Returns TRUE if the line table set tracks token locations across
 macro expansion, FALSE otherwise.  */
 bool
-linemap_tracks_macro_expansion_locs_p (struct line_maps *set)
+linemap_tracks_macro_expansion_locs_p (line_maps *set)
 {
 return LINEMAPS_MACRO_MAPS (set) != NULL;
 }
 /* Create a macro map.  A macro map encodes source locations of tokens
 locations, this function returns NULL.  In that case, callers of
 this function cannot encode {line,column} pairs into locations of
 macro tokens anymore.  */
 const line_map_macro *
-linemap_enter_macro (struct line_maps *set, struct cpp_hashnode *macro_node,
+linemap_enter_macro (class line_maps *set, struct cpp_hashnode *macro_node,
-		     source_location expansion, unsigned int num_tokens)
+		     location_t expansion, unsigned int num_tokens)
 {
-source_location start_location
+location_t start_location
 = LINEMAPS_MACRO_LOWEST_LOCATION (set) - num_tokens;
 if (start_location < LINE_MAP_MAX_LOCATION)
 /* We ran out of macro map space.   */
 return NULL;
 line_map_macro *map = linemap_check_macro (new_linemap (set, start_location));
 map->macro = macro_node;
 map->n_tokens = num_tokens;
 map->macro_locations
-= (source_location*) set->reallocator (NULL,
+= (location_t*) set->reallocator (NULL,
 					   2 * num_tokens
-					   * sizeof (source_location));
+					   * sizeof (location_t));
 map->expansion = expansion;
 memset (MACRO_MAP_LOCATIONS (map), 0,
-	  2 * num_tokens * sizeof (source_location));
+	  2 * num_tokens * sizeof (location_t));
 LINEMAPS_MACRO_CACHE (set) = LINEMAPS_MACRO_USED (set) - 1;
 return map;
 }
 ORIG_PARM_REPLACEMENT_LOC is the location in the macro definition,
 either of the token itself or of a macro parameter that it
 replaces.  */
-source_location
+location_t
 linemap_add_macro_token (const line_map_macro *map,
 			 unsigned int token_no,
-			 source_location orig_loc,
+			 location_t orig_loc,
-			 source_location orig_parm_replacement_loc)
+			 location_t orig_parm_replacement_loc)
 {
-source_location result;
+location_t result;
 linemap_assert (linemap_macro_expansion_map_p (map));
 linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
 MACRO_MAP_LOCATIONS (map)[2 * token_no] = orig_loc;
 result = MAP_START_LOCATION (map) + token_no;
 return result;
 }
-/* Return a source_location for the start (i.e. column==0) of
+/* Return a location_t for the start (i.e. column==0) of
 (physical) line TO_LINE in the current source file (as in the
 most recent linemap_add).   MAX_COLUMN_HINT is the highest column
 number we expect to use in this line (but it does not change
 the highest_location).  */
-source_location
+location_t
-linemap_line_start (struct line_maps *set, linenum_type to_line,
+linemap_line_start (line_maps *set, linenum_type to_line,
 		    unsigned int max_column_hint)
 {
 line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set);
-source_location highest = set->highest_location;
+location_t highest = set->highest_location;
-source_location r;
+location_t r;
 linenum_type last_line =
 SOURCE_LINE (map, set->highest_line);
 int line_delta = to_line - last_line;
 bool add_map = false;
 linemap_assert (map->m_column_and_range_bits >= map->m_range_bits);
 int range_bits;
 if (max_column_hint > LINE_MAP_MAX_COLUMN_NUMBER
 	  || highest > LINE_MAP_MAX_LOCATION_WITH_COLS)
 	{
 	  /* If the column number is ridiculous or we've allocated a huge
-	     number of source_locations, give up on column numbers
+	     number of location_ts, give up on column numbers
 	     (and on packed ranges).  */
-	  max_column_hint = 0;
+	  max_column_hint = 1;
 	  column_bits = 0;
 	  range_bits = 0;
 	  if (highest >= LINE_MAP_MAX_LOCATION)
-	    return 0;
+	    goto overflowed;
 	}
 else
 	{
 	  column_bits = 7;
 	  if (highest <= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES)
 	  while (max_column_hint >= (1U << column_bits))
 	    column_bits++;
 	  max_column_hint = 1U << column_bits;
 	  column_bits += range_bits;
 	}
 /* Allocate the new line_map.  However, if the current map only has a
 	 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 - range_bits))
+	  || ( /* We can't reuse the map if the line offset is sufficiently
+		  large to cause overflow when computing location_t values.  */
+	      (to_line - ORDINARY_MAP_STARTING_LINE_NUMBER (map))
+	      >= (((uint64_t) 1)
+		  << (CHAR_BIT * sizeof (linenum_type) - column_bits)))
 	  || range_bits < map->m_range_bits)
 	map = linemap_check_ordinary
 	        (const_cast <line_map *>
 		  (linemap_add (set, LC_RENAME,
 				ORDINARY_MAP_IN_SYSTEM_HEADER_P (map),
 r = set->highest_line + (line_delta << map->m_column_and_range_bits);
 /* Locations of ordinary tokens are always lower than locations of
 macro tokens.  */
 if (r >= LINE_MAP_MAX_LOCATION)
-return 0;
+{
+overflowed:
+/* Remember we overflowed.  */
+set->highest_line = set->highest_location = LINE_MAP_MAX_LOCATION - 1;
+/* No column numbers!  */
+set->max_column_hint = 1;
+return 0;
+}
 set->highest_line = r;
 if (r > set->highest_location)
 set->highest_location = r;
 set->max_column_hint = max_column_hint;
 		  || map->m_column_and_range_bits == 0);
 linemap_assert (SOURCE_LINE (map, r) == to_line);
 return r;
 }
-/* Encode and return a source_location from a column number. The
+/* Encode and return a location_t from a column number. The
 source line considered is the last source line used to call
 linemap_line_start, i.e, the last source line which a location was
 encoded from.  */
-source_location
+location_t
-linemap_position_for_column (struct line_maps *set, unsigned int to_column)
+linemap_position_for_column (line_maps *set, unsigned int to_column)
 {
-source_location r = set->highest_line;
+location_t r = set->highest_line;
 linemap_assert
 (!linemap_macro_expansion_map_p (LINEMAPS_LAST_ORDINARY_MAP (set)));
 if (to_column >= set->max_column_hint)
 {
 if (r > LINE_MAP_MAX_LOCATION_WITH_COLS
 	  || to_column > LINE_MAP_MAX_COLUMN_NUMBER)
 	{
-	  /* Running low on source_locations - disable column numbers.  */
+	  /* Running low on location_ts - disable column numbers.  */
 	  return r;
 	}
 else
 	{
 	  /* Otherwise, attempt to start a new line that can hold TO_COLUMN,
 }
 /* Encode and return a source location from a given line and
 column.  */
-source_location
+location_t
 linemap_position_for_line_and_column (line_maps *set,
 				      const line_map_ordinary *ord_map,
 				      linenum_type line,
 				      unsigned column)
 {
 linemap_assert (ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map) <= line);
-source_location r = MAP_START_LOCATION (ord_map);
+location_t r = MAP_START_LOCATION (ord_map);
 r += ((line - ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map))
 	<< ord_map->m_column_and_range_bits);
 if (r <= LINE_MAP_MAX_LOCATION_WITH_COLS)
 r += ((column & ((1 << ord_map->m_column_and_range_bits) - 1))
 	  << ord_map->m_range_bits);
-source_location upper_limit = LINEMAPS_MACRO_LOWEST_LOCATION (set);
+location_t upper_limit = LINEMAPS_MACRO_LOWEST_LOCATION (set);
 if (r >= upper_limit)
 r = upper_limit - 1;
 if (r > set->highest_location)
 set->highest_location = r;
 return r;
 }
-/* Encode and return a source_location starting from location LOC and
+/* Encode and return a location_t starting from location LOC and
 shifting it by COLUMN_OFFSET columns.  This function does not support
 virtual locations.  */
-source_location
+location_t
-linemap_position_for_loc_and_offset (struct line_maps *set,
+linemap_position_for_loc_and_offset (line_maps *set,
-				     source_location loc,
+				     location_t loc,
 				     unsigned int column_offset)
 {
 const line_map_ordinary * map = NULL;
 if (IS_ADHOC_LOC (loc))
-loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
+loc = get_location_from_adhoc_loc (set, loc);
 /* This function does not support virtual locations yet.  */
 if (linemap_location_from_macro_expansion_p (set, loc))
 return loc;
 /* 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 =
+location_t r =
 linemap_position_for_line_and_column (set, map, line, column);
 if (linemap_assert_fails (r <= set->highest_location)
 || linemap_assert_fails (map == linemap_lookup (set, r)))
 return loc;
 /* Given a virtual source location yielded by a map (either an
 ordinary or a macro map), returns that map.  */
 const struct line_map*
-linemap_lookup (struct line_maps *set, source_location line)
+linemap_lookup (const line_maps *set, location_t line)
 {
 if (IS_ADHOC_LOC (line))
-line = set->location_adhoc_data_map.data[line & MAX_SOURCE_LOCATION].locus;
+line = get_location_from_adhoc_loc (set, line);
 if (linemap_location_from_macro_expansion_p (set, line))
 return linemap_macro_map_lookup (set, line);
 return linemap_ordinary_map_lookup (set, line);
 }
 map.  Since the set is built chronologically, the logical lines are
 monotonic increasing, and so the list is sorted and we can use a
 binary search.  */
 static const line_map_ordinary *
-linemap_ordinary_map_lookup (struct line_maps *set, source_location line)
+linemap_ordinary_map_lookup (const line_maps *set, location_t line)
 {
 unsigned int md, mn, mx;
 const line_map_ordinary *cached, *result;
 if (IS_ADHOC_LOC (line))
-line = set->location_adhoc_data_map.data[line & MAX_SOURCE_LOCATION].locus;
+line = get_location_from_adhoc_loc (set, line);
 if (set ==  NULL || line < RESERVED_LOCATION_COUNT)
 return NULL;
 mn = LINEMAPS_ORDINARY_CACHE (set);
 mx = LINEMAPS_ORDINARY_USED (set);
 cached = LINEMAPS_ORDINARY_MAP_AT (set, mn);
 /* We should get a segfault if no line_maps have been added yet.  */
 if (line >= MAP_START_LOCATION (cached))
 {
 if (mn + 1 == mx || line < MAP_START_LOCATION (&cached[1]))
 Since the set is built chronologically, the logical lines are
 monotonic decreasing, and so the list is sorted and we can use a
 binary search.  */
 static const line_map_macro *
-linemap_macro_map_lookup (struct line_maps *set, source_location line)
+linemap_macro_map_lookup (const line_maps *set, location_t line)
 {
 unsigned int md, mn, mx;
 const struct line_map_macro *cached, *result;
 if (IS_ADHOC_LOC (line))
-line = set->location_adhoc_data_map.data[line & MAX_SOURCE_LOCATION].locus;
+line = get_location_from_adhoc_loc (set, line);
 linemap_assert (line >= LINEMAPS_MACRO_LOWEST_LOCATION (set));
 if (set ==  NULL)
 return NULL;
 macro expansion return the location of the macro expansion point.
 Read the comments of struct line_map and struct line_map_macro in
 line-map.h to understand what a macro expansion point is.  */
-static source_location
+static location_t
 linemap_macro_map_loc_to_exp_point (const line_map_macro *map,
-				    source_location location ATTRIBUTE_UNUSED)
+				    location_t location ATTRIBUTE_UNUSED)
 {
 linemap_assert (linemap_macro_expansion_map_p (map)
 		  && location >= MAP_START_LOCATION (map));
 /* Make sure LOCATION is correct.  */
 replacement-list as part of the macro expansion denoted by MAP.
 Return the location of the token at the definition point of the
 macro.  */
-static source_location
+static location_t
 linemap_macro_map_loc_to_def_point (const line_map_macro *map,
-				    source_location location)
+				    location_t location)
 {
 unsigned token_no;
 linemap_assert (linemap_macro_expansion_map_p (map)
 		  && location >= MAP_START_LOCATION (map));
 function-like macro M and appears in the expansion of M, return the
 locus of that argument in the context of the caller of M.
 In other words, this returns the xI location presented in the
 comments of line_map_macro above.  */
-source_location
+location_t
 linemap_macro_map_loc_unwind_toward_spelling (line_maps *set,
 					      const line_map_macro* map,
-					      source_location location)
+					      location_t location)
 {
 unsigned token_no;
 if (IS_ADHOC_LOC (location))
 location = get_location_from_adhoc_loc (set, location);
 LOCATION is the source location of token that is part of the
 replacement-list of a macro expansion return the line number of the
 macro expansion point.  */
 int
-linemap_get_expansion_line (struct line_maps *set,
+linemap_get_expansion_line (line_maps *set,
-			    source_location location)
+			    location_t location)
 {
 const line_map_ordinary *map = NULL;
 if (IS_ADHOC_LOC (location))
-location = set->location_adhoc_data_map.data[location
+location = get_location_from_adhoc_loc (set, location);
-						 & MAX_SOURCE_LOCATION].locus;
 if (location < RESERVED_LOCATION_COUNT)
 return 0;
 location =
 macro expansion point.
 SET is the line map set LOCATION comes from.  */
 const char*
-linemap_get_expansion_filename (struct line_maps *set,
+linemap_get_expansion_filename (line_maps *set,
-				source_location location)
+				location_t location)
 {
 const struct line_map_ordinary *map = NULL;
 if (IS_ADHOC_LOC (location))
-location = set->location_adhoc_data_map.data[location
+location = get_location_from_adhoc_loc (set, location);
-						 & MAX_SOURCE_LOCATION].locus;
 if (location < RESERVED_LOCATION_COUNT)
 return NULL;
-location =
+linemap_macro_loc_to_exp_point (set, location, &map);
-linemap_macro_loc_to_exp_point (set, location, &map);
 return LINEMAP_FILE (map);
 }
 /* Return the name of the macro associated to MACRO_MAP.  */
 Note that this function returns 1 if LOCATION belongs to a token
 that is part of a macro replacement-list defined in a system
 header, but expanded in a non-system file.  */
 int
-linemap_location_in_system_header_p (struct line_maps *set,
+linemap_location_in_system_header_p (line_maps *set,
-				     source_location location)
+				     location_t location)
 {
 const struct line_map *map = NULL;
 if (IS_ADHOC_LOC (location))
-location = set->location_adhoc_data_map.data[location
+location = get_location_from_adhoc_loc (set, location);
-						 & MAX_SOURCE_LOCATION].locus;
 if (location < RESERVED_LOCATION_COUNT)
 return false;
 /* Let's look at where the token for LOCATION comes from.  */
 	  else
 	    {
 	      const line_map_macro *macro_map = linemap_check_macro (map);
 	      /* It's a token resulting from a macro expansion.  */
-	      source_location loc =
+	      location_t loc =
 		linemap_macro_map_loc_unwind_toward_spelling (set, macro_map, location);
 	      if (loc < RESERVED_LOCATION_COUNT)
 		/* This token might come from a built-in macro.  Let's
 		   look at where that macro got expanded.  */
 		location = linemap_macro_map_loc_to_exp_point (macro_map, location);
 /* 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,
+linemap_location_from_macro_expansion_p (const class line_maps *set,
-					 source_location location)
+					 location_t location)
 {
 if (IS_ADHOC_LOC (location))
-location = set->location_adhoc_data_map.data[location
+location = get_location_from_adhoc_loc (set, location);
-						 & MAX_SOURCE_LOCATION].locus;
+return IS_MACRO_LOC (location);
-return location >= LINE_MAP_MAX_LOCATION;
 }
 /* Given two virtual locations *LOC0 and *LOC1, return the first
 common macro map in their macro expansion histories.  Return NULL
 if no common macro was found.  *LOC0 (resp. *LOC1) is set to the
 virtual location of the token inside the resulting macro.  */
 static const struct line_map*
-first_map_in_common_1 (struct line_maps *set,
+first_map_in_common_1 (line_maps *set,
-		       source_location *loc0,
+		       location_t *loc0,
-		       source_location *loc1)
+		       location_t *loc1)
 {
-source_location l0 = *loc0, l1 = *loc1;
+location_t l0 = *loc0, l1 = *loc1;
-const struct line_map *map0 = linemap_lookup (set, l0),
+const struct line_map *map0 = linemap_lookup (set, l0);
-*map1 = linemap_lookup (set, l1);
+if (IS_ADHOC_LOC (l0))
+l0 = get_location_from_adhoc_loc (set, l0);
+const struct line_map *map1 = linemap_lookup (set, l1);
+if (IS_ADHOC_LOC (l1))
+l1 = get_location_from_adhoc_loc (set, l1);
 while (linemap_macro_expansion_map_p (map0)
 	 && linemap_macro_expansion_map_p (map1)
 	 && (map0 != map1))
 {
 common macro was found.  *RES_LOC0 (resp. *RES_LOC1) is set to the
 virtual location of the token inside the resulting macro, upon
 return of a non-NULL result.  */
 static const struct line_map*
-first_map_in_common (struct line_maps *set,
+first_map_in_common (line_maps *set,
-		     source_location loc0,
+		     location_t loc0,
-		     source_location loc1,
+		     location_t loc1,
-		     source_location  *res_loc0,
+		     location_t  *res_loc0,
-		     source_location  *res_loc1)
+		     location_t  *res_loc1)
 {
 *res_loc0 = loc0;
 *res_loc1 = loc1;
 return first_map_in_common_1 (set, res_loc0, res_loc1);
 comes before the token of POST, 0 if PRE denotes the location of
 the same token as the token for POST, and a negative value
 otherwise.  */
 int
-linemap_compare_locations (struct line_maps *set,
+linemap_compare_locations (line_maps *set,
-			   source_location  pre,
+			   location_t  pre,
-			   source_location post)
+			   location_t post)
 {
 bool pre_virtual_p, post_virtual_p;
-source_location l0 = pre, l1 = post;
+location_t l0 = pre, l1 = post;
 if (IS_ADHOC_LOC (l0))
 l0 = get_location_from_adhoc_loc (set, l0);
 if (IS_ADHOC_LOC (l1))
 l1 = get_location_from_adhoc_loc (set, l1);
 }
 /* Print an include trace, for e.g. the -H option of the preprocessor.  */
 static void
-trace_include (const struct line_maps *set, const line_map_ordinary *map)
+trace_include (const class line_maps *set, const line_map_ordinary *map)
 {
 unsigned int i = set->depth;
 while (--i)
 putc ('.', stderr);
 /* Return the spelling location of the token wherever it comes from,
 whether part of a macro definition or not.
 This is a subroutine for linemap_resolve_location.  */
-static source_location
+static location_t
-linemap_macro_loc_to_spelling_point (struct line_maps *set,
+linemap_macro_loc_to_spelling_point (line_maps *set,
-				     source_location location,
+				     location_t location,
 				     const line_map_ordinary **original_map)
 {
 linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
 while (true)
 the function sets *ORIGINAL_MAP to the ordinary (non-macro) map the
 returned location comes from.
 This is a subroutine of linemap_resolve_location.  */
-static source_location
+static location_t
-linemap_macro_loc_to_def_point (struct line_maps *set,
+linemap_macro_loc_to_def_point (line_maps *set,
-				source_location location,
+				location_t location,
 				const line_map_ordinary **original_map)
 {
 linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
 for (;;)
 {
-source_location caret_loc = location;
+location_t caret_loc = location;
 if (IS_ADHOC_LOC (caret_loc))
 	caret_loc = get_location_from_adhoc_loc (set, caret_loc);
 const line_map *map = linemap_lookup (set, caret_loc);
 if (!map || MAP_ORDINARY_P (map))
 sets *ORIGINAL_MAP to the ordinary (non-macro) map the returned
 location comes from.
 This is a subroutine of linemap_resolve_location.  */
-static source_location
+static location_t
-linemap_macro_loc_to_exp_point (struct line_maps *set,
+linemap_macro_loc_to_exp_point (line_maps *set,
-				source_location location,
+				location_t location,
 				const line_map_ordinary **original_map)
 {
 struct line_map *map;
 if (IS_ADHOC_LOC (location))
-location = set->location_adhoc_data_map.data[location
+location = get_location_from_adhoc_loc (set, location);
-						 & MAX_SOURCE_LOCATION].locus;
 linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
 while (true)
 {
 returned location.  Note that if the returned location wasn't originally
 encoded by a map, then *MAP is set to NULL.  This can happen if LOC
 resolves to a location reserved for the client code, like
 UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC.  */
-source_location
+location_t
-linemap_resolve_location (struct line_maps *set,
+linemap_resolve_location (line_maps *set,
-			  source_location loc,
+			  location_t loc,
 			  enum location_resolution_kind lrk,
 			  const line_map_ordinary **map)
 {
-source_location locus = loc;
+location_t locus = loc;
 if (IS_ADHOC_LOC (loc))
-locus = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
+locus = get_location_from_adhoc_loc (set, loc);
 if (locus < RESERVED_LOCATION_COUNT)
 {
 /* A reserved location wasn't encoded in a map.  Let's return a
 	 NULL map here, just like what linemap_ordinary_map_lookup
 /* 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,
+linemap_location_from_macro_definition_p (line_maps *set,
-					  source_location loc)
+					  location_t loc)
 {
 if (IS_ADHOC_LOC (loc))
 loc = get_location_from_adhoc_loc (set, loc);
 if (!linemap_location_from_macro_expansion_p (set, loc))
 while (true)
 {
 const struct line_map_macro *map
 	= linemap_check_macro (linemap_lookup (set, loc));
-source_location s_loc
+location_t 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
+	  location_t def_loc
 	    = linemap_macro_map_loc_to_def_point (map, loc);
 	  return s_loc == def_loc;
 	}
 }
 }
 the expansion of M.
 *LOC_MAP must be set to the map of LOC.  This function then sets it
 to the map of the returned location.  */
-source_location
+location_t
-linemap_unwind_toward_expansion (struct line_maps *set,
+linemap_unwind_toward_expansion (line_maps *set,
-				 source_location loc,
+				 location_t loc,
 				 const struct line_map **map)
 {
-source_location resolved_location;
+location_t resolved_location;
 const line_map_macro *macro_map = linemap_check_macro (*map);
 const struct line_map *resolved_map;
 if (IS_ADHOC_LOC (loc))
-loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
+loc = get_location_from_adhoc_loc (set, loc);
 resolved_location =
 linemap_macro_map_loc_unwind_toward_spelling (set, macro_map, loc);
 resolved_map = linemap_lookup (set, resolved_location);
 LOC doesn't come from the expansion of a macro, the function
 returns LOC as is and *MAP is not touched.
 *MAP is set to the map of the returned location if the later is
 different from LOC.  */
-source_location
+location_t
-linemap_unwind_to_first_non_reserved_loc (struct line_maps *set,
+linemap_unwind_to_first_non_reserved_loc (line_maps *set,
-					  source_location loc,
+					  location_t loc,
 					  const struct line_map **map)
 {
-source_location resolved_loc;
+location_t resolved_loc;
 const struct line_map *map0 = NULL;
 const line_map_ordinary *map1 = NULL;
 if (IS_ADHOC_LOC (loc))
-loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
+loc = get_location_from_adhoc_loc (set, loc);
 map0 = linemap_lookup (set, loc);
 if (!linemap_macro_expansion_map_p (map0))
 return loc;
 code location.  LOC must be a spelling (non-virtual) location.  If
 it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source
 location is returned.  */
 expanded_location
-linemap_expand_location (struct line_maps *set,
+linemap_expand_location (line_maps *set,
 			 const struct line_map *map,
-			 source_location loc)
+			 location_t loc)
 {
 expanded_location xloc;
 memset (&xloc, 0, sizeof (xloc));
 if (IS_ADHOC_LOC (loc))
 {
-xloc.data
+xloc.data = get_data_from_adhoc_loc (set, loc);
-	= set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].data;
+loc = get_location_from_adhoc_loc (set, loc);
-loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
 }
 if (loc < RESERVED_LOCATION_COUNT)
 /* The location for this token wasn't generated from a line map.
 It was probably a location for a builtin token, chosen by some
 /* Dump line map at index IX in line table SET to STREAM.  If STREAM
 is NULL, use stderr.  IS_MACRO is true if the caller wants to
 dump a macro map, false otherwise.  */
 void
-linemap_dump (FILE *stream, struct line_maps *set, unsigned ix, bool is_macro)
+linemap_dump (FILE *stream, class line_maps *set, unsigned ix, bool is_macro)
 {
 const char *const lc_reasons_v[LC_HWM]
 = { "LC_ENTER", "LC_LEAVE", "LC_RENAME", "LC_RENAME_VERBATIM",
 	  "LC_ENTER_MACRO" };
 const line_map *map;
 /* Dump debugging information about source location LOC into the file
 stream STREAM. SET is the line map set LOC comes from.  */
 void
-linemap_dump_location (struct line_maps *set,
+linemap_dump_location (line_maps *set,
-		       source_location loc,
+		       location_t loc,
 		       FILE *stream)
 {
 const line_map_ordinary *map;
-source_location location;
+location_t location;
 const char *path = "", *from = "";
 int l = -1, c = -1, s = -1, e = -1;
 if (IS_ADHOC_LOC (loc))
-loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
+loc = get_location_from_adhoc_loc (set, loc);
 if (loc == 0)
 return;
 location =
 there is a line map in SET.  FILE_NAME is the file name to
 consider.  If the function returns TRUE, *LOC is set to the highest
 location emitted for that file.  */
 bool
-linemap_get_file_highest_location (struct line_maps *set,
+linemap_get_file_highest_location (line_maps *set,
 				   const char *file_name,
-				   source_location *loc)
+				   location_t *loc)
 {
 /* If the set is empty or no ordinary map has been created then
 there is no file to look for ...  */
 if (set == NULL || set->info_ordinary.used == 0)
 return false;
 return false;
 /* The highest location for a given map is either the starting
 location of the next map minus one, or -- if the map is the
 latest one -- the highest location of the set.  */
-source_location result;
+location_t result;
 if (i == (int) set->info_ordinary.used - 1)
 result = set->highest_location;
 else
 result = set->info_ordinary.maps[i + 1].start_location - 1;
 /* Compute and return statistics about the memory consumption of some
 parts of the line table SET.  */
 void
-linemap_get_statistics (struct line_maps *set,
+linemap_get_statistics (line_maps *set,
 			struct linemap_stats *s)
 {
 long ordinary_maps_allocated_size, ordinary_maps_used_size,
 macro_maps_allocated_size, macro_maps_used_size,
 macro_maps_locations_size = 0, duplicated_macro_maps_locations_size = 0;
 unsigned i;
 linemap_assert (linemap_macro_expansion_map_p (cur_map));
 macro_maps_locations_size +=
-	2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map) * sizeof (source_location);
+	2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map) * sizeof (location_t);
 for (i = 0; i < 2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map); i += 2)
 	{
 	  if (MACRO_MAP_LOCATIONS (cur_map)[i] ==
 	      MACRO_MAP_LOCATIONS (cur_map)[i + 1])
 	    duplicated_macro_maps_locations_size +=
-	      sizeof (source_location);
+	      sizeof (location_t);
 	}
 }
 macro_maps_used_size =
 LINEMAPS_MACRO_USED (set) * sizeof (struct line_map_macro);
 /* Dump line table SET to STREAM.  If STREAM is NULL, stderr is used.
 NUM_ORDINARY specifies how many ordinary maps to dump.  NUM_MACRO
 specifies how many macro maps to dump.  */
 void
-line_table_dump (FILE *stream, struct line_maps *set, unsigned int num_ordinary,
+line_table_dump (FILE *stream, class line_maps *set, unsigned int num_ordinary,
 		 unsigned int num_macro)
 {
 unsigned int i;
 if (set == NULL)
 /* class rich_location.  */
 /* Construct a rich_location with location LOC as its initial range.  */
-rich_location::rich_location (line_maps *set, source_location loc,
+rich_location::rich_location (line_maps *set, location_t loc,
 			      const range_label *label) :
 m_line_table (set),
 m_ranges (),
 m_column_override (0),
 m_have_expanded_location (false),
 m_fixit_hints (),
 m_seen_impossible_fixit (false),
-m_fixits_cannot_be_auto_applied (false)
+m_fixits_cannot_be_auto_applied (false),
+m_path (NULL)
 {
 add_range (loc, SHOW_RANGE_WITH_CARET, label);
 }
 /* The destructor for class rich_location.  */
 delete get_fixit_hint (i);
 }
 /* Get location IDX within this rich_location.  */
-source_location
+location_t
 rich_location::get_loc (unsigned int idx) const
 {
 const location_range *locrange = get_range (idx);
 return locrange->m_loc;
 }
 }
 /* Add the given range.  */
 void
-rich_location::add_range (source_location loc,
+rich_location::add_range (location_t loc,
 			  enum range_display_kind range_display_kind,
 			  const range_label *label)
 {
 location_range range;
 range.m_loc = loc;
 (which writes the source location of a tree back into location 0 of
 the rich_location), and
 - the "%C" and "%L" format codes in the Fortran frontend.  */
 void
-rich_location::set_range (unsigned int idx, source_location loc,
+rich_location::set_range (unsigned int idx, location_t loc,
 			  enum range_display_kind range_display_kind)
 {
 /* We can either overwrite an existing range, or add one exactly
 on the end of the array.  */
 linemap_assert (idx <= m_ranges.count ());
 /* 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,
+rich_location::add_fixit_insert_before (location_t where,
 					const char *new_content)
 {
-source_location start = get_range_from_loc (m_line_table, where).m_start;
+location_t start = get_range_from_loc (m_line_table, where).m_start;
 maybe_add_fixit (start, start, new_content);
 }
 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
 immediately after the primary range's end-point.  */
 /* 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,
+rich_location::add_fixit_insert_after (location_t where,
 				       const char *new_content)
 {
-source_location finish = get_range_from_loc (m_line_table, where).m_finish;
+location_t finish = get_range_from_loc (m_line_table, where).m_finish;
-source_location next_loc
+location_t 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)
 /* 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)
+rich_location::add_fixit_remove (location_t where)
 {
 source_range range = get_range_from_loc (m_line_table, where);
 add_fixit_remove (range);
 }
 /* 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,
+rich_location::add_fixit_replace (location_t where,
 				  const char *new_content)
 {
 source_range range = get_range_from_loc (m_line_table, where);
 add_fixit_replace (range, new_content);
 }
 void
 rich_location::add_fixit_replace (source_range src_range,
 				  const char *new_content)
 {
-source_location start = get_pure_location (m_line_table, src_range.m_start);
+location_t start = get_pure_location (m_line_table, src_range.m_start);
-source_location finish = get_pure_location (m_line_table, src_range.m_finish);
+location_t finish = get_pure_location (m_line_table, src_range.m_finish);
 /* Fix-it hints use half-closed ranges, so attempt to offset the endpoint.  */
-source_location next_loc
+location_t 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)
 {
 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)
+rich_location::reject_impossible_fixit (location_t 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.  */
 /* Add HINT to the fix-it hints in this rich_location,
 consolidating into the prior fixit if possible.  */
 void
-rich_location::maybe_add_fixit (source_location start,
+rich_location::maybe_add_fixit (location_t start,
-				source_location next_loc,
+				location_t next_loc,
 				const char *new_content)
 {
 if (reject_impossible_fixit (start))
 return;
 if (reject_impossible_fixit (next_loc))
 m_fixit_hints.push (new fixit_hint (start, next_loc, new_content));
 }
 /* class fixit_hint.  */
-fixit_hint::fixit_hint (source_location start,
+fixit_hint::fixit_hint (location_t start,
-			source_location next_loc,
+			location_t next_loc,
 			const char *new_content)
 : m_start (start),
 m_next_loc (next_loc),
 m_bytes (xstrdup (new_content)),
 m_len (strlen (new_content))
 If possible, merge a pending fix-it hint with the given params
 into this one and return true.
 Otherwise return false.  */
 bool
-fixit_hint::maybe_append (source_location start,
+fixit_hint::maybe_append (location_t start,
-			  source_location next_loc,
+			  location_t next_loc,
 			  const char *new_content)
 {
 /* For consolidation to be possible, START must be at this hint's
 m_next_loc.  */
 if (start != m_next_loc)

Mercurial > hg > CbC > CbC_gcc

comparison libcpp/line-map.c @ 145:1830386684a0