diff options
Diffstat (limited to 'libcpp/line-map.cc')
| -rw-r--r-- | libcpp/line-map.cc | 2555 |
1 files changed, 2555 insertions, 0 deletions
diff --git a/libcpp/line-map.cc b/libcpp/line-map.cc new file mode 100644 index 0000000..91ac2d3 --- /dev/null +++ b/libcpp/line-map.cc @@ -0,0 +1,2555 @@ +/* Map (unsigned int) keys to (source file, line, column) triples. + Copyright (C) 2001-2022 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. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; see the file COPYING3. If not see +<http://www.gnu.org/licenses/>. + + In other words, you are welcome to use, share and improve this program. + You are forbidden to forbid anyone else to use, share and improve + what you give them. Help stamp out software-hoarding! */ + +#include "config.h" +#include "system.h" +#include "line-map.h" +#include "cpplib.h" +#include "internal.h" +#include "hashtab.h" + +static void trace_include (const line_maps *, const line_map_ordinary *); +static const line_map_ordinary * linemap_ordinary_map_lookup (const line_maps *, + location_t); +static const line_map_macro* linemap_macro_map_lookup (const line_maps *, + location_t); +static location_t linemap_macro_map_loc_to_def_point +(const line_map_macro *, location_t); +static location_t linemap_macro_map_loc_to_exp_point +(const line_map_macro *, location_t); +static location_t linemap_macro_loc_to_spelling_point +(line_maps *, location_t, const line_map_ordinary **); +static location_t linemap_macro_loc_to_def_point (line_maps *, + location_t, + const line_map_ordinary **); +static location_t linemap_macro_loc_to_exp_point (line_maps *, + location_t, + const line_map_ordinary **); + +/* Counters defined in macro.c. */ +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 () +{ + if (location_adhoc_data_map.htab) + htab_delete (location_adhoc_data_map.htab); +} + +/* Hash function for location_adhoc_data hashtable. */ + +static hashval_t +location_adhoc_data_hash (const void *l) +{ + const struct location_adhoc_data *lb = + (const struct location_adhoc_data *) l; + return ((hashval_t) lb->locus + + (hashval_t) lb->src_range.m_start + + (hashval_t) lb->src_range.m_finish + + (size_t) lb->data); +} + +/* Compare function for location_adhoc_data hashtable. */ + +static int +location_adhoc_data_eq (const void *l1, const void *l2) +{ + const struct location_adhoc_data *lb1 = + (const struct location_adhoc_data *) l1; + const struct location_adhoc_data *lb2 = + (const struct location_adhoc_data *) l2; + return (lb1->locus == lb2->locus + && lb1->src_range.m_start == lb2->src_range.m_start + && lb1->src_range.m_finish == lb2->src_range.m_finish + && lb1->data == lb2->data); +} + +/* Update the hashtable when location_adhoc_data is reallocated. */ + +static int +location_adhoc_data_update (void **slot, void *data) +{ + *((char **) slot) + = (char *) ((uintptr_t) *((char **) slot) + *((ptrdiff_t *) data)); + return 1; +} + +/* Rebuild the hash table from the location adhoc data. */ + +void +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++) + htab_find_slot (set->location_adhoc_data_map.htab, + 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 location_t, without needing to use an ad-hoc location. */ + +static bool +can_be_stored_compactly_p (line_maps *set, + location_t locus, + source_range src_range, + void *data) +{ + /* If there's an ad-hoc pointer, we can't store it directly in the + 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 (src_range.m_start != locus) + return false; + + if (src_range.m_finish < src_range.m_start) + return false; + + if (src_range.m_start < RESERVED_LOCATION_COUNT) + return false; + + if (locus >= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES) + return false; + + /* All 3 locations must be within ordinary maps, typically, the same + ordinary map. */ + 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 false; + + /* Passed all tests. */ + return true; +} + +/* Combine LOCUS and DATA to a combined adhoc loc. */ + +location_t +get_combined_adhoc_loc (line_maps *set, + 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 = get_location_from_adhoc_loc (set, locus); + if (locus == 0 && data == NULL) + return 0; + + /* Any ordinary locations ought to be "pure" at this point: no + compressed ranges. */ + linemap_assert (locus < RESERVED_LOCATION_COUNT + || locus >= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES + || locus >= LINEMAPS_MACRO_LOWEST_LOCATION (set) + || pure_location_p (set, locus)); + + /* Consider short-range optimization. */ + if (can_be_stored_compactly_p (set, locus, src_range, data)) + { + /* The low bits ought to be clear. */ + linemap_assert (pure_location_p (set, locus)); + const line_map *map = linemap_lookup (set, locus); + 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)) + { + location_t packed = locus | col_diff; + set->num_optimized_ranges++; + return packed; + } + } + + /* We can also compactly store locations + when locus == start == finish (and data is NULL). */ + if (locus == src_range.m_start + && locus == src_range.m_finish + && !data) + return locus; + + if (!data) + set->num_unoptimized_ranges++; + + lb.locus = locus; + lb.src_range = src_range; + lb.data = data; + slot = (struct location_adhoc_data **) + htab_find_slot (set->location_adhoc_data_map.htab, &lb, INSERT); + if (*slot == NULL) + { + if (set->location_adhoc_data_map.curr_loc >= + set->location_adhoc_data_map.allocated) + { + char *orig_data = (char *) set->location_adhoc_data_map.data; + ptrdiff_t offset; + /* Cast away extern "C" from the type of xrealloc. */ + line_map_realloc reallocator = (set->reallocator + ? set->reallocator + : (line_map_realloc) xrealloc); + + if (set->location_adhoc_data_map.allocated == 0) + set->location_adhoc_data_map.allocated = 128; + else + set->location_adhoc_data_map.allocated *= 2; + set->location_adhoc_data_map.data = (struct location_adhoc_data *) + reallocator (set->location_adhoc_data_map.data, + set->location_adhoc_data_map.allocated + * sizeof (struct location_adhoc_data)); + offset = (char *) (set->location_adhoc_data_map.data) - orig_data; + if (set->location_adhoc_data_map.allocated > 128) + htab_traverse (set->location_adhoc_data_map.htab, + location_adhoc_data_update, &offset); + } + *slot = set->location_adhoc_data_map.data + + set->location_adhoc_data_map.curr_loc; + set->location_adhoc_data_map.data[set->location_adhoc_data_map.curr_loc++] + = lb; + } + return ((*slot) - set->location_adhoc_data_map.data) | 0x80000000; +} + +/* Return the data for the adhoc loc. */ + +void * +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_LOCATION_T].data; +} + +/* Return the location for the adhoc loc. */ + +location_t +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_LOCATION_T].locus; +} + +/* Return the source_range for adhoc location LOC. */ + +static source_range +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_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 (line_maps *set, + location_t loc) +{ + if (IS_ADHOC_LOC (loc)) + return get_range_from_adhoc_loc (set, loc); + + /* For ordinary maps, extract packed range. */ + if (loc >= RESERVED_LOCATION_COUNT + && loc < LINEMAPS_MACRO_LOWEST_LOCATION (set) + && loc <= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES) + { + const line_map *map = linemap_lookup (set, loc); + const line_map_ordinary *ordmap = linemap_check_ordinary (map); + source_range result; + int offset = loc & ((1 << ordmap->m_range_bits) - 1); + result.m_start = loc - offset; + result.m_finish = result.m_start + (offset << ordmap->m_range_bits); + return result; + } + + return source_range::from_location (loc); +} + +/* 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, location_t loc) +{ + if (IS_ADHOC_LOC (loc)) + return false; + + const line_map *map = linemap_lookup (set, loc); + if (map == NULL) + return true; + const line_map_ordinary *ordmap = linemap_check_ordinary (map); + + if (loc & ((1U << ordmap->m_range_bits) - 1)) + return false; + + return true; +} + +/* Given location LOC within SET, strip away any packed range information + or ad-hoc information. */ + +location_t +get_pure_location (line_maps *set, location_t loc) +{ + if (IS_ADHOC_LOC (loc)) + loc = get_location_from_adhoc_loc (set, loc); + + 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. */ + +void +linemap_init (line_maps *set, + location_t builtin_location) +{ +#if __GNUC__ == 4 && __GNUC_MINOR__ == 2 && !defined (__clang__) + /* PR33916, needed to fix PR82939. */ + memset (set, 0, sizeof (line_maps)); +#else + new (set) line_maps(); +#endif + /* Set default reallocator (used for initial alloc too). */ + set->reallocator = xrealloc; + set->highest_location = RESERVED_LOCATION_COUNT - 1; + set->highest_line = RESERVED_LOCATION_COUNT - 1; + set->location_adhoc_data_map.htab = + htab_create (100, location_adhoc_data_hash, location_adhoc_data_eq, NULL); + set->builtin_location = builtin_location; +} + +/* Return the ordinary line map from whence MAP was included. Returns + NULL if MAP was not an include. */ + +const line_map_ordinary * +linemap_included_from_linemap (line_maps *set, const line_map_ordinary *map) +{ + return linemap_ordinary_map_lookup (set, linemap_included_from (map)); +} + +/* Check for and warn about line_maps entered but not exited. */ + +void +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); + map = linemap_included_from_linemap (set, map)) + fprintf (stderr, "line-map.c: file \"%s\" entered but not left\n", + ORDINARY_MAP_FILE_NAME (map)); +} + +/* Create NUM zero-initialized maps of type MACRO_P. */ + +line_map * +line_map_new_raw (line_maps *set, bool macro_p, unsigned num) +{ + unsigned num_maps_allocated = LINEMAPS_ALLOCATED (set, macro_p); + unsigned num_maps_used = LINEMAPS_USED (set, macro_p); + + if (num > num_maps_allocated - num_maps_used) + { + /* We need more space! */ + if (!num_maps_allocated) + num_maps_allocated = 128; + if (num_maps_allocated < num_maps_used + num) + num_maps_allocated = num_maps_used + num; + num_maps_allocated *= 2; + + size_t size_of_a_map; + void *buffer; + if (macro_p) + { + size_of_a_map = sizeof (line_map_macro); + buffer = set->info_macro.maps; + } + else + { + size_of_a_map = 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 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 (num_maps_allocated * size_of_a_map); + + /* 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 map that amounts to. */ + unsigned num_maps = alloc_size / size_of_a_map; + buffer = set->reallocator (buffer, num_maps * size_of_a_map); + memset ((char *)buffer + num_maps_used * size_of_a_map, 0, + (num_maps - num_maps_used) * size_of_a_map); + if (macro_p) + set->info_macro.maps = (line_map_macro *)buffer; + else + set->info_ordinary.maps = (line_map_ordinary *)buffer; + LINEMAPS_ALLOCATED (set, macro_p) = num_maps; + } + + line_map *result = (macro_p ? (line_map *)&set->info_macro.maps[num_maps_used] + : (line_map *)&set->info_ordinary.maps[num_maps_used]); + LINEMAPS_USED (set, macro_p) += num; + + return result; +} + +/* Create a new line map in the line map set SET, and return it. + 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 (line_maps *set, location_t start_location) +{ + line_map *result = line_map_new_raw (set, + start_location >= LINE_MAP_MAX_LOCATION, + 1); + + result->start_location = start_location; + + return result; +} + +/* Return the location of the last source line within an ordinary + map. */ +inline location_t +LAST_SOURCE_LINE_LOCATION (const line_map_ordinary *map) +{ + return (((map[1].start_location - 1 + - map->start_location) + & ~((1 << map->m_column_and_range_bits) - 1)) + + map->start_location); +} + +/* Add a mapping of logical source line to physical source file and + line number. + + The text pointed to by TO_FILE must have a lifetime + at least as long as the final call to lookup_line (). An empty + TO_FILE means standard input. If reason is LC_LEAVE, and + TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their + natural values considering the file we are returning to. + + 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 (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. */ + location_t start_location = set->highest_location + 1; + unsigned range_bits = 0; + if (start_location < LINE_MAP_MAX_LOCATION_WITH_COLS) + range_bits = set->default_range_bits; + start_location += (1 << range_bits) - 1; + start_location &= ~((1 << range_bits) - 1); + + linemap_assert (!LINEMAPS_ORDINARY_USED (set) + || (start_location + >= MAP_START_LOCATION (LINEMAPS_LAST_ORDINARY_MAP (set)))); + + /* When we enter the file for the first time reason cannot be + LC_RENAME. */ + linemap_assert (!(set->depth == 0 && reason == LC_RENAME)); + + /* If we are leaving the main file, return a NULL map. */ + if (reason == LC_LEAVE + && MAIN_FILE_P (LINEMAPS_LAST_ORDINARY_MAP (set)) + && to_file == NULL) + { + set->depth--; + return NULL; + } + + linemap_assert (reason != LC_ENTER_MACRO); + + if (start_location >= LINE_MAP_MAX_LOCATION) + /* We ran out of line map space. */ + start_location = 0; + + line_map_ordinary *map + = linemap_check_ordinary (new_linemap (set, start_location)); + map->reason = reason; + + if (to_file && *to_file == '\0' && reason != LC_RENAME_VERBATIM) + to_file = "<stdin>"; + + if (reason == LC_RENAME_VERBATIM) + reason = LC_RENAME; + + const line_map_ordinary *from = NULL; + if (reason == LC_LEAVE) + { + /* When we are just leaving an "included" file, and jump to the next + location inside the "includer" right after the #include + "included", this variable points the map in use right before the + #include "included", inside the same "includer" file. */ + + linemap_assert (!MAIN_FILE_P (map - 1)); + /* (MAP - 1) points to the map we are leaving. The + map from which (MAP - 1) got included should be the map + that comes right before MAP in the same file. */ + from = linemap_included_from_linemap (set, map - 1); + + /* A TO_FILE of NULL is special - we use the natural values. */ + if (to_file == NULL) + { + to_file = ORDINARY_MAP_FILE_NAME (from); + to_line = SOURCE_LINE (from, from[1].start_location); + sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (from); + } + else + linemap_assert (filename_cmp (ORDINARY_MAP_FILE_NAME (from), + to_file) == 0); + } + + map->sysp = sysp; + map->to_file = to_file; + map->to_line = to_line; + LINEMAPS_ORDINARY_CACHE (set) = LINEMAPS_ORDINARY_USED (set) - 1; + /* Do not store range_bits here. That's readjusted in + linemap_line_start. */ + map->m_range_bits = map->m_column_and_range_bits = 0; + set->highest_location = start_location; + set->highest_line = start_location; + set->max_column_hint = 0; + + /* This assertion is placed after set->highest_location has + been updated, since the latter affects + linemap_location_from_macro_expansion_p, which ultimately affects + pure_location_p. */ + linemap_assert (pure_location_p (set, start_location)); + + if (reason == LC_ENTER) + { + if (set->depth == 0) + map->included_from = 0; + else + /* The location of the end of the just-closed map. */ + map->included_from + = (((map[0].start_location - 1 - map[-1].start_location) + & ~((1 << map[-1].m_column_and_range_bits) - 1)) + + map[-1].start_location); + set->depth++; + if (set->trace_includes) + trace_include (set, map); + } + else if (reason == LC_RENAME) + map->included_from = linemap_included_from (&map[-1]); + else if (reason == LC_LEAVE) + { + set->depth--; + map->included_from = linemap_included_from (from); + } + + return map; +} + +/* Create a location for a module NAME imported at FROM. */ + +location_t +linemap_module_loc (line_maps *set, location_t from, const char *name) +{ + const line_map_ordinary *map + = linemap_check_ordinary (linemap_add (set, LC_MODULE, false, name, 0)); + const_cast <line_map_ordinary *> (map)->included_from = from; + + location_t loc = linemap_line_start (set, 0, 0); + + return loc; +} + +/* The linemap containing LOC is being reparented to be + imported/included from ADOPTOR. This can happen when an + indirectly imported module is then directly imported, or when + partitions are involved. */ + +void +linemap_module_reparent (line_maps *set, location_t loc, location_t adoptor) +{ + const line_map_ordinary *map = linemap_ordinary_map_lookup (set, loc); + const_cast<line_map_ordinary *> (map)->included_from = adoptor; +} + +/* A linemap at LWM-1 was interrupted to insert module locations & imports. + Append a new map, continuing the interrupted one. Return the start location + of the new map, or 0 if failed (because we ran out of locations. */ + +unsigned +linemap_module_restore (line_maps *set, unsigned lwm) +{ + linemap_assert (lwm); + + const line_map_ordinary *pre_map + = linemap_check_ordinary (LINEMAPS_MAP_AT (set, false, lwm - 1)); + unsigned src_line = SOURCE_LINE (pre_map, LAST_SOURCE_LINE_LOCATION (pre_map)); + location_t inc_at = pre_map->included_from; + if (const line_map_ordinary *post_map + = (linemap_check_ordinary + (linemap_add (set, LC_RENAME_VERBATIM, + ORDINARY_MAP_IN_SYSTEM_HEADER_P (pre_map), + ORDINARY_MAP_FILE_NAME (pre_map), src_line)))) + { + /* linemap_add will think we were included from the same as the preceeding + map. */ + const_cast <line_map_ordinary *> (post_map)->included_from = inc_at; + + return post_map->start_location; + } + + return 0; +} + +/* Returns TRUE if the line table set tracks token locations across + macro expansion, FALSE otherwise. */ + +bool +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 + that are part of a macro replacement-list, at a macro expansion + point. See the extensive comments of struct line_map and struct + line_map_macro, in line-map.h. + + This map shall be created when the macro is expanded. The map + encodes the source location of the expansion point of the macro as + well as the "original" source location of each token that is part + of the macro replacement-list. If a macro is defined but never + expanded, it has no macro map. SET is the set of maps the macro + map should be part of. MACRO_NODE is the macro which the new macro + map should encode source locations for. EXPANSION is the location + of the expansion point of MACRO. For function-like macros + invocations, it's best to make it point to the closing parenthesis + of the macro, rather than the the location of the first character + of the macro. NUM_TOKENS is the number of tokens that are part of + the replacement-list of MACRO. + + Note that when we run out of the integer space available for source + 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 (class line_maps *set, struct cpp_hashnode *macro_node, + location_t expansion, unsigned int num_tokens) +{ + 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 + = (location_t*) set->reallocator (NULL, + 2 * num_tokens + * sizeof (location_t)); + map->expansion = expansion; + memset (MACRO_MAP_LOCATIONS (map), 0, + 2 * num_tokens * sizeof (location_t)); + + LINEMAPS_MACRO_CACHE (set) = LINEMAPS_MACRO_USED (set) - 1; + + return map; +} + +/* Create and return a virtual location for a token that is part of a + macro expansion-list at a macro expansion point. See the comment + inside struct line_map_macro to see what an expansion-list exactly + is. + + A call to this function must come after a call to + linemap_enter_macro. + + MAP is the map into which the source location is created. TOKEN_NO + is the index of the token in the macro replacement-list, starting + at number 0. + + ORIG_LOC is the location of the token outside of this macro + expansion. If the token comes originally from the macro + definition, it is the locus in the macro definition; otherwise it + is a location in the context of the caller of this macro expansion + (which is a virtual location or a source location if the caller is + itself a macro expansion or not). + + ORIG_PARM_REPLACEMENT_LOC is the location in the macro definition, + either of the token itself or of a macro parameter that it + replaces. */ + +location_t +linemap_add_macro_token (const line_map_macro *map, + unsigned int token_no, + location_t orig_loc, + location_t orig_parm_replacement_loc) +{ + 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; + MACRO_MAP_LOCATIONS (map)[2 * token_no + 1] = orig_parm_replacement_loc; + + result = MAP_START_LOCATION (map) + token_no; + return result; +} + +/* 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). */ + +location_t +linemap_line_start (line_maps *set, linenum_type to_line, + unsigned int max_column_hint) +{ + line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set); + location_t highest = set->highest_location; + 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 effective_column_bits = map->m_column_and_range_bits - map->m_range_bits; + + if (line_delta < 0 + || (line_delta > 10 + && line_delta * map->m_column_and_range_bits > 1000) + || (max_column_hint >= (1U << effective_column_bits)) + || (max_column_hint <= 80 && effective_column_bits >= 10) + || (highest > LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES + && map->m_range_bits > 0) + || (highest > LINE_MAP_MAX_LOCATION_WITH_COLS + && (set->max_column_hint || highest >= LINE_MAP_MAX_LOCATION))) + add_map = true; + else + max_column_hint = set->max_column_hint; + if (add_map) + { + int column_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 location_ts, give up on column numbers + (and on packed ranges). */ + max_column_hint = 1; + column_bits = 0; + range_bits = 0; + if (highest >= LINE_MAP_MAX_LOCATION) + goto overflowed; + } + else + { + column_bits = 7; + if (highest <= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES) + range_bits = set->default_range_bits; + else + range_bits = 0; + 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), + ORDINARY_MAP_FILE_NAME (map), + to_line))); + map->m_column_and_range_bits = column_bits; + map->m_range_bits = range_bits; + r = (MAP_START_LOCATION (map) + + ((to_line - ORDINARY_MAP_STARTING_LINE_NUMBER (map)) + << column_bits)); + } + else + 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) + { + 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; + + /* At this point, we expect one of: + (a) the normal case: a "pure" location with 0 range bits, or + (b) we've gone past LINE_MAP_MAX_LOCATION_WITH_COLS so can't track + columns anymore (or ranges), or + (c) we're in a region with a column hint exceeding + LINE_MAP_MAX_COLUMN_NUMBER, so column-tracking is off, + with column_bits == 0. */ + linemap_assert (pure_location_p (set, r) + || r >= LINE_MAP_MAX_LOCATION_WITH_COLS + || map->m_column_and_range_bits == 0); + linemap_assert (SOURCE_LINE (map, r) == to_line); + return r; +} + +/* 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. */ + +location_t +linemap_position_for_column (line_maps *set, unsigned int to_column) +{ + 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 location_ts - disable column numbers. */ + return r; + } + 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); + r = r + (to_column << map->m_range_bits); + if (r >= set->highest_location) + set->highest_location = r; + return r; +} + +/* Encode and return a source location from a given line and + column. */ + +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); + + 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); + 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 location_t starting from location LOC and + shifting it by COLUMN_OFFSET columns. This function does not support + virtual locations. */ + +location_t +linemap_position_for_loc_and_offset (line_maps *set, + location_t loc, + unsigned int column_offset) +{ + const line_map_ordinary * map = NULL; + + if (IS_ADHOC_LOC (loc)) + 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; + + if (column_offset == 0 + /* Adding an offset to a reserved location (like + UNKNOWN_LOCATION for the C/C++ FEs) does not really make + sense. So let's leave the location intact in that case. */ + || loc < RESERVED_LOCATION_COUNT) + return loc; + + /* We find the real location and shift it. */ + loc = linemap_resolve_location (set, loc, LRK_SPELLING_LOCATION, &map); + /* The new location (loc + offset) should be higher than the first + location encoded by MAP. This can fail if the line information + is messed up because of line directives (see PR66415). */ + if (MAP_START_LOCATION (map) >= loc + (column_offset << map->m_range_bits)) + return loc; + + linenum_type line = SOURCE_LINE (map, loc); + unsigned int column = SOURCE_COLUMN (map, loc); + + /* If MAP is not the last line map of its set, then the new location + (loc + offset) should be less than the first location encoded by + the next line map of the set. Otherwise, we try to encode the + location in the next map. */ + for (; map != LINEMAPS_LAST_ORDINARY_MAP (set) + && (loc + (column_offset << map->m_range_bits) + >= MAP_START_LOCATION (map + 1)); map++) + /* If the next map is a different file, or starts in a higher line, we + cannot encode the location there. */ + if ((map + 1)->reason != LC_RENAME + || line < ORDINARY_MAP_STARTING_LINE_NUMBER (map + 1) + || 0 != strcmp (LINEMAP_FILE (map + 1), LINEMAP_FILE (map))) + return loc; + + column += column_offset; + + /* 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; + + 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; + + return r; +} + +/* 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 (const line_maps *set, location_t line) +{ + if (IS_ADHOC_LOC (line)) + 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); +} + +/* Given a source location yielded by an ordinary map, returns that + 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 (const line_maps *set, location_t line) +{ + if (IS_ADHOC_LOC (line)) + line = get_location_from_adhoc_loc (set, line); + + if (set == NULL || line < RESERVED_LOCATION_COUNT) + return NULL; + + unsigned mn = LINEMAPS_ORDINARY_CACHE (set); + unsigned mx = LINEMAPS_ORDINARY_USED (set); + + const line_map_ordinary *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])) + return cached; + } + else + { + mx = mn; + mn = 0; + } + + while (mx - mn > 1) + { + unsigned md = (mn + mx) / 2; + if (MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (set, md)) > line) + mx = md; + else + mn = md; + } + + LINEMAPS_ORDINARY_CACHE (set) = mn; + const line_map_ordinary *result = LINEMAPS_ORDINARY_MAP_AT (set, mn); + linemap_assert (line >= MAP_START_LOCATION (result)); + return result; +} + +/* Given a source location yielded by a macro map, returns that map. + 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 (const line_maps *set, location_t line) +{ + if (IS_ADHOC_LOC (line)) + line = get_location_from_adhoc_loc (set, line); + + linemap_assert (line >= LINEMAPS_MACRO_LOWEST_LOCATION (set)); + + if (set == NULL) + return NULL; + + unsigned ix = linemap_lookup_macro_index (set, line); + const struct line_map_macro *result = LINEMAPS_MACRO_MAP_AT (set, ix); + linemap_assert (MAP_START_LOCATION (result) <= line); + + return result; +} + +unsigned +linemap_lookup_macro_index (const line_maps *set, location_t line) +{ + unsigned mn = LINEMAPS_MACRO_CACHE (set); + unsigned mx = LINEMAPS_MACRO_USED (set); + const struct line_map_macro *cached = LINEMAPS_MACRO_MAP_AT (set, mn); + + if (line >= MAP_START_LOCATION (cached)) + { + if (line < (MAP_START_LOCATION (cached) + + MACRO_MAP_NUM_MACRO_TOKENS (cached))) + return mn; + mx = mn - 1; + mn = 0; + } + + while (mn < mx) + { + unsigned md = (mx + mn) / 2; + if (MAP_START_LOCATION (LINEMAPS_MACRO_MAP_AT (set, md)) > line) + mn = md + 1; + else + mx = md; + } + + LINEMAPS_MACRO_CACHE (set) = mx; + return mx; +} + +/* Return TRUE if MAP encodes locations coming from a macro + replacement-list at macro expansion point. */ + +bool +linemap_macro_expansion_map_p (const struct line_map *map) +{ + return map && !MAP_ORDINARY_P (map); +} + +/* If LOCATION is the locus of a token in a replacement-list of a + 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 location_t +linemap_macro_map_loc_to_exp_point (const line_map_macro *map, + location_t location ATTRIBUTE_UNUSED) +{ + linemap_assert (linemap_macro_expansion_map_p (map) + && location >= MAP_START_LOCATION (map)); + + /* Make sure LOCATION is correct. */ + linemap_assert ((location - MAP_START_LOCATION (map)) + < MACRO_MAP_NUM_MACRO_TOKENS (map)); + + return MACRO_MAP_EXPANSION_POINT_LOCATION (map); +} + +/* LOCATION is the source location of a token that belongs to a macro + 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 location_t +linemap_macro_map_loc_to_def_point (const line_map_macro *map, + location_t location) +{ + unsigned token_no; + + linemap_assert (linemap_macro_expansion_map_p (map) + && location >= MAP_START_LOCATION (map)); + linemap_assert (location >= RESERVED_LOCATION_COUNT); + + token_no = location - MAP_START_LOCATION (map); + linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map)); + + location = MACRO_MAP_LOCATIONS (map)[2 * token_no + 1]; + + return location; +} + +/* If LOCATION is the locus of a token that is an argument of a + 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. */ +location_t +linemap_macro_map_loc_unwind_toward_spelling (line_maps *set, + const line_map_macro* map, + location_t location) +{ + unsigned token_no; + + if (IS_ADHOC_LOC (location)) + location = get_location_from_adhoc_loc (set, location); + + linemap_assert (linemap_macro_expansion_map_p (map) + && location >= MAP_START_LOCATION (map)); + linemap_assert (location >= RESERVED_LOCATION_COUNT); + linemap_assert (!IS_ADHOC_LOC (location)); + + token_no = location - MAP_START_LOCATION (map); + linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map)); + + location = MACRO_MAP_LOCATIONS (map)[2 * token_no]; + + return location; +} + +/* Return the source line number corresponding to source location + LOCATION. SET is the line map set LOCATION comes from. If + 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 (line_maps *set, + location_t location) +{ + const line_map_ordinary *map = NULL; + + if (IS_ADHOC_LOC (location)) + location = get_location_from_adhoc_loc (set, location); + + if (location < RESERVED_LOCATION_COUNT) + return 0; + + location = + linemap_macro_loc_to_exp_point (set, location, &map); + + return SOURCE_LINE (map, location); +} + +/* Return the path of the file corresponding to source code location + LOCATION. + + If LOCATION is the source location of token that is part of the + replacement-list of a macro expansion return the file path of the + macro expansion point. + + SET is the line map set LOCATION comes from. */ + +const char* +linemap_get_expansion_filename (line_maps *set, + location_t location) +{ + const struct line_map_ordinary *map = NULL; + + if (IS_ADHOC_LOC (location)) + location = get_location_from_adhoc_loc (set, location); + + if (location < RESERVED_LOCATION_COUNT) + return NULL; + + linemap_macro_loc_to_exp_point (set, location, &map); + + return LINEMAP_FILE (map); +} + +/* Return the name of the macro associated to MACRO_MAP. */ + +const char* +linemap_map_get_macro_name (const line_map_macro *macro_map) +{ + linemap_assert (macro_map && linemap_macro_expansion_map_p (macro_map)); + return (const char*) NODE_NAME (MACRO_MAP_MACRO (macro_map)); +} + +/* Return a positive value if LOCATION is the locus of a token that is + located in a system header, O otherwise. It returns 1 if LOCATION + is the locus of a token that is located in a system header, and 2 + if LOCATION is the locus of a token located in a C system header + that therefore needs to be extern "C" protected in C++. + + 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 (line_maps *set, + location_t location) +{ + const struct line_map *map = NULL; + + if (IS_ADHOC_LOC (location)) + location = get_location_from_adhoc_loc (set, location); + + if (location < RESERVED_LOCATION_COUNT) + return false; + + /* Let's look at where the token for LOCATION comes from. */ + while (true) + { + map = linemap_lookup (set, location); + if (map != NULL) + { + if (!linemap_macro_expansion_map_p (map)) + /* It's a normal token. */ + return LINEMAP_SYSP (linemap_check_ordinary (map)); + else + { + const line_map_macro *macro_map = linemap_check_macro (map); + + /* It's a token resulting from a macro expansion. */ + 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); + else + location = loc; + } + } + else + break; + } + return false; +} + +/* 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 class line_maps *set, + location_t location) +{ + if (IS_ADHOC_LOC (location)) + location = get_location_from_adhoc_loc (set, location); + + return location >= LINEMAPS_MACRO_LOWEST_LOCATION (set); +} + +/* 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 (line_maps *set, + location_t *loc0, + location_t *loc1) +{ + location_t l0 = *loc0, l1 = *loc1; + const struct line_map *map0 = linemap_lookup (set, l0); + 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)) + { + if (MAP_START_LOCATION (map0) < MAP_START_LOCATION (map1)) + { + l0 = linemap_macro_map_loc_to_exp_point (linemap_check_macro (map0), + l0); + map0 = linemap_lookup (set, l0); + } + else + { + l1 = linemap_macro_map_loc_to_exp_point (linemap_check_macro (map1), + l1); + map1 = linemap_lookup (set, l1); + } + } + + if (map0 == map1) + { + *loc0 = l0; + *loc1 = l1; + return map0; + } + return NULL; +} + +/* 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. *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. */ + +const struct line_map* +first_map_in_common (line_maps *set, + location_t loc0, + location_t loc1, + location_t *res_loc0, + location_t *res_loc1) +{ + *res_loc0 = loc0; + *res_loc1 = loc1; + + return first_map_in_common_1 (set, res_loc0, res_loc1); +} + +/* Return a positive value if PRE denotes the location of a token that + 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 (line_maps *set, + location_t pre, + location_t post) +{ + bool pre_virtual_p, post_virtual_p; + 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); + + if (l0 == l1) + return 0; + + if ((pre_virtual_p = linemap_location_from_macro_expansion_p (set, l0))) + l0 = linemap_resolve_location (set, l0, + LRK_MACRO_EXPANSION_POINT, + NULL); + + if ((post_virtual_p = linemap_location_from_macro_expansion_p (set, l1))) + l1 = linemap_resolve_location (set, l1, + LRK_MACRO_EXPANSION_POINT, + NULL); + + if (l0 == l1 + && pre_virtual_p + && post_virtual_p) + { + /* So pre and post represent two tokens that are present in a + same macro expansion. Let's see if the token for pre was + before the token for post in that expansion. */ + const struct line_map *map = + first_map_in_common (set, pre, post, &l0, &l1); + + if (map == NULL) + /* This should not be possible while we have column information, but if + we don't, the tokens could be from separate macro expansions on the + same line. */ + gcc_assert (l0 > LINE_MAP_MAX_LOCATION_WITH_COLS); + else + { + unsigned i0 = l0 - MAP_START_LOCATION (map); + unsigned i1 = l1 - MAP_START_LOCATION (map); + return i1 - i0; + } + } + + 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); + + return l1 - l0; +} + +/* Print an include trace, for e.g. the -H option of the preprocessor. */ + +static void +trace_include (const class line_maps *set, const line_map_ordinary *map) +{ + unsigned int i = set->depth; + + while (--i) + putc ('.', stderr); + + fprintf (stderr, " %s\n", ORDINARY_MAP_FILE_NAME (map)); +} + +/* 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 location_t +linemap_macro_loc_to_spelling_point (line_maps *set, + location_t location, + const line_map_ordinary **original_map) +{ + linemap_assert (set && location >= RESERVED_LOCATION_COUNT); + + while (true) + { + const struct line_map *map = linemap_lookup (set, location); + if (!map || MAP_ORDINARY_P (map)) + { + if (original_map) + *original_map = (const line_map_ordinary *)map; + break; + } + + location = linemap_macro_map_loc_unwind_toward_spelling + (set, linemap_check_macro (map), location); + } + + return location; +} + +/* If LOCATION is the source location of a token that belongs to a + macro replacement-list -- as part of a macro expansion -- then + return the location of the token at the definition point of the + macro. Otherwise, return LOCATION. SET is the set of maps + location come from. ORIGINAL_MAP is an output parm. If non NULL, + 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 location_t +linemap_macro_loc_to_def_point (line_maps *set, + location_t location, + const line_map_ordinary **original_map) +{ + linemap_assert (set && location >= RESERVED_LOCATION_COUNT); + + for (;;) + { + 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)) + { + if (original_map) + *original_map = (const line_map_ordinary *)map; + break; + } + + location = linemap_macro_map_loc_to_def_point + (linemap_check_macro (map), caret_loc); + } + + return location; +} + +/* If LOCATION is the source location of a token that belongs to a + macro replacement-list -- at a macro expansion point -- then return + the location of the topmost expansion point of the macro. We say + topmost because if we are in the context of a nested macro + expansion, the function returns the source location of the first + macro expansion that triggered the nested expansions. + + Otherwise, return LOCATION. SET is the set of maps location come + from. ORIGINAL_MAP is an output parm. If non NULL, 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 location_t +linemap_macro_loc_to_exp_point (line_maps *set, + location_t location, + const line_map_ordinary **original_map) +{ + struct line_map *map; + + if (IS_ADHOC_LOC (location)) + location = get_location_from_adhoc_loc (set, location); + + linemap_assert (set && location >= RESERVED_LOCATION_COUNT); + + while (true) + { + map = const_cast <line_map *> (linemap_lookup (set, location)); + if (!linemap_macro_expansion_map_p (map)) + break; + location = linemap_macro_map_loc_to_exp_point (linemap_check_macro (map), + location); + } + + if (original_map) + *original_map = linemap_check_ordinary (map); + return location; +} + +/* Resolve a virtual location into either a spelling location, an + expansion point location or a token argument replacement point + location. Return the map that encodes the virtual location as well + as the resolved location. + + If LOC is *NOT* the location of a token resulting from the + expansion of a macro, then the parameter LRK (which stands for + Location Resolution Kind) is ignored and the resulting location + just equals the one given in argument. + + Now if LOC *IS* the location of a token resulting from the + expansion of a macro, this is what happens. + + * If LRK is set to LRK_MACRO_EXPANSION_POINT + ------------------------------- + + The virtual location is resolved to the first macro expansion point + that led to this macro expansion. + + * If LRK is set to LRK_SPELLING_LOCATION + ------------------------------------- + + The virtual location is resolved to the locus where the token has + been spelled in the source. This can follow through all the macro + expansions that led to the token. + + * If LRK is set to LRK_MACRO_DEFINITION_LOCATION + -------------------------------------- + + The virtual location is resolved to the locus of the token in the + context of the macro definition. + + If LOC is the locus of a token that is an argument of a + function-like macro [replacing a parameter in the replacement list + of the macro] the virtual location is resolved to the locus of the + parameter that is replaced, in the context of the definition of the + macro. + + If LOC is the locus of a token that is not an argument of a + function-like macro, then the function behaves as if LRK was set to + LRK_SPELLING_LOCATION. + + If MAP is not NULL, *MAP is set to the map encoding the + 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. */ + +location_t +linemap_resolve_location (line_maps *set, + location_t loc, + enum location_resolution_kind lrk, + const line_map_ordinary **map) +{ + location_t locus = loc; + if (IS_ADHOC_LOC (loc)) + 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 + does. */ + if (map) + *map = NULL; + return loc; + } + + switch (lrk) + { + case LRK_MACRO_EXPANSION_POINT: + loc = linemap_macro_loc_to_exp_point (set, loc, map); + break; + case LRK_SPELLING_LOCATION: + loc = linemap_macro_loc_to_spelling_point (set, loc, map); + break; + case LRK_MACRO_DEFINITION_LOCATION: + loc = linemap_macro_loc_to_def_point (set, loc, map); + break; + default: + abort (); + } + 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 (line_maps *set, + 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)) + return false; + + while (true) + { + const struct line_map_macro *map + = linemap_check_macro (linemap_lookup (set, 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 + { + location_t 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 + location L of the point where M got expanded. If L is a spelling + location inside a macro expansion M', then this function returns + the locus of the point where M' was expanded. Said otherwise, this + function returns the location of T in the context that triggered + 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. */ + +location_t +linemap_unwind_toward_expansion (line_maps *set, + location_t loc, + const struct line_map **map) +{ + 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 = 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); + + if (!linemap_macro_expansion_map_p (resolved_map)) + { + resolved_location = linemap_macro_map_loc_to_exp_point (macro_map, loc); + resolved_map = linemap_lookup (set, resolved_location); + } + + *map = resolved_map; + return resolved_location; +} + +/* If LOC is the virtual location of a token coming from the expansion + of a macro M and if its spelling location is reserved (e.g, a + location for a built-in token), then this function unwinds (using + linemap_unwind_toward_expansion) the location until a location that + is not reserved and is not in a system header is reached. In other + words, this unwinds the reserved location until a location that is + in real source code is reached. + + Otherwise, if the spelling location for LOC is not reserved or if + 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. */ +location_t +linemap_unwind_to_first_non_reserved_loc (line_maps *set, + location_t loc, + const struct line_map **map) +{ + location_t resolved_loc; + const struct line_map *map0 = NULL; + const line_map_ordinary *map1 = NULL; + + if (IS_ADHOC_LOC (loc)) + loc = get_location_from_adhoc_loc (set, loc); + + map0 = linemap_lookup (set, loc); + if (!linemap_macro_expansion_map_p (map0)) + return loc; + + resolved_loc = linemap_resolve_location (set, loc, + LRK_SPELLING_LOCATION, + &map1); + + if (resolved_loc >= RESERVED_LOCATION_COUNT + && !LINEMAP_SYSP (map1)) + return loc; + + while (linemap_macro_expansion_map_p (map0) + && (resolved_loc < RESERVED_LOCATION_COUNT + || LINEMAP_SYSP (map1))) + { + loc = linemap_unwind_toward_expansion (set, loc, &map0); + resolved_loc = linemap_resolve_location (set, loc, + LRK_SPELLING_LOCATION, + &map1); + } + + if (map != NULL) + *map = map0; + return loc; +} + +/* Expand source code location LOC and return a user readable source + 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 (line_maps *set, + const struct line_map *map, + location_t loc) + +{ + expanded_location xloc; + + memset (&xloc, 0, sizeof (xloc)); + if (IS_ADHOC_LOC (loc)) + { + xloc.data = get_data_from_adhoc_loc (set, loc); + loc = get_location_from_adhoc_loc (set, loc); + } + + 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 + client code. Let's not try to expand the location in that + case. */; + else if (map == NULL) + /* We shouldn't be getting a NULL map with a location that is not + reserved by the client code. */ + abort (); + else + { + /* MAP must be an ordinary map and LOC must be non-virtual, + encoded into this map, obviously; the accessors used on MAP + below ensure it is ordinary. Let's just assert the + non-virtualness of LOC here. */ + if (linemap_location_from_macro_expansion_p (set, loc)) + abort (); + + const line_map_ordinary *ord_map = linemap_check_ordinary (map); + + xloc.file = LINEMAP_FILE (ord_map); + xloc.line = SOURCE_LINE (ord_map, loc); + xloc.column = SOURCE_COLUMN (ord_map, loc); + xloc.sysp = LINEMAP_SYSP (ord_map) != 0; + } + + return xloc; +} + + +/* 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, 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", "LC_MODULE" }; + const line_map *map; + unsigned reason; + + if (stream == NULL) + stream = stderr; + + if (!is_macro) + { + map = LINEMAPS_ORDINARY_MAP_AT (set, ix); + reason = linemap_check_ordinary (map)->reason; + } + else + { + map = LINEMAPS_MACRO_MAP_AT (set, ix); + reason = LC_ENTER_MACRO; + } + + fprintf (stream, "Map #%u [%p] - LOC: %u - REASON: %s - SYSP: %s\n", + ix, (void *) map, map->start_location, + reason < LC_HWM ? lc_reasons_v[reason] : "???", + ((!is_macro + && ORDINARY_MAP_IN_SYSTEM_HEADER_P (linemap_check_ordinary (map))) + ? "yes" : "no")); + if (!is_macro) + { + const line_map_ordinary *ord_map = linemap_check_ordinary (map); + const line_map_ordinary *includer_map + = linemap_included_from_linemap (set, ord_map); + + fprintf (stream, "File: %s:%d\n", ORDINARY_MAP_FILE_NAME (ord_map), + ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map)); + fprintf (stream, "Included from: [%d] %s\n", + includer_map ? int (includer_map - set->info_ordinary.maps) : -1, + includer_map ? ORDINARY_MAP_FILE_NAME (includer_map) : "None"); + } + else + { + const line_map_macro *macro_map = linemap_check_macro (map); + fprintf (stream, "Macro: %s (%u tokens)\n", + linemap_map_get_macro_name (macro_map), + MACRO_MAP_NUM_MACRO_TOKENS (macro_map)); + } + + fprintf (stream, "\n"); +} + + +/* 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 (line_maps *set, + location_t loc, + FILE *stream) +{ + const line_map_ordinary *map; + location_t location; + const char *path = "", *from = ""; + int l = -1, c = -1, s = -1, e = -1; + + if (IS_ADHOC_LOC (loc)) + loc = get_location_from_adhoc_loc (set, loc); + + if (loc == 0) + return; + + location = + linemap_resolve_location (set, loc, LRK_MACRO_DEFINITION_LOCATION, &map); + + if (map == NULL) + /* Only reserved locations can be tolerated in this case. */ + linemap_assert (location < RESERVED_LOCATION_COUNT); + else + { + path = LINEMAP_FILE (map); + l = SOURCE_LINE (map, location); + c = SOURCE_COLUMN (map, location); + s = LINEMAP_SYSP (map) != 0; + e = location != loc; + if (e) + from = "N/A"; + else + { + const line_map_ordinary *from_map + = linemap_included_from_linemap (set, map); + from = from_map ? LINEMAP_FILE (from_map) : "<NULL>"; + } + } + + /* P: path, L: line, C: column, S: in-system-header, M: map address, + E: macro expansion?, LOC: original location, R: resolved location */ + fprintf (stream, "{P:%s;F:%s;L:%d;C:%d;S:%d;M:%p;E:%d,LOC:%d,R:%d}", + path, from, l, c, s, (void*)map, e, loc, location); +} + +/* Return the highest location emitted for a given file for which + 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 (line_maps *set, + const char *file_name, + 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; + + /* Now look for the last ordinary map created for FILE_NAME. */ + int i; + for (i = set->info_ordinary.used - 1; i >= 0; --i) + { + const char *fname = set->info_ordinary.maps[i].to_file; + if (fname && !filename_cmp (fname, file_name)) + break; + } + + if (i < 0) + 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. */ + 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; + + *loc = result; + return true; +} + +/* Compute and return statistics about the memory consumption of some + parts of the line table SET. */ + +void +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; + + const line_map_macro *cur_map; + + ordinary_maps_allocated_size = + LINEMAPS_ORDINARY_ALLOCATED (set) * sizeof (struct line_map_ordinary); + + ordinary_maps_used_size = + LINEMAPS_ORDINARY_USED (set) * sizeof (struct line_map_ordinary); + + macro_maps_allocated_size = + LINEMAPS_MACRO_ALLOCATED (set) * sizeof (struct line_map_macro); + + for (cur_map = LINEMAPS_MACRO_MAPS (set); + cur_map && cur_map <= LINEMAPS_LAST_MACRO_MAP (set); + ++cur_map) + { + unsigned i; + + linemap_assert (linemap_macro_expansion_map_p (cur_map)); + + macro_maps_locations_size += + 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 (location_t); + } + } + + macro_maps_used_size = + LINEMAPS_MACRO_USED (set) * sizeof (struct line_map_macro); + + s->num_ordinary_maps_allocated = LINEMAPS_ORDINARY_ALLOCATED (set); + s->num_ordinary_maps_used = LINEMAPS_ORDINARY_USED (set); + s->ordinary_maps_allocated_size = ordinary_maps_allocated_size; + s->ordinary_maps_used_size = ordinary_maps_used_size; + s->num_expanded_macros = num_expanded_macros_counter; + s->num_macro_tokens = num_macro_tokens_counter; + s->num_macro_maps_used = LINEMAPS_MACRO_USED (set); + s->macro_maps_allocated_size = macro_maps_allocated_size; + s->macro_maps_locations_size = macro_maps_locations_size; + s->macro_maps_used_size = macro_maps_used_size; + s->duplicated_macro_maps_locations_size = + duplicated_macro_maps_locations_size; + s->adhoc_table_size = (set->location_adhoc_data_map.allocated + * sizeof (struct location_adhoc_data)); + s->adhoc_table_entries_used = set->location_adhoc_data_map.curr_loc; +} + + +/* 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, class line_maps *set, unsigned int num_ordinary, + unsigned int num_macro) +{ + unsigned int i; + + if (set == NULL) + return; + + if (stream == NULL) + stream = stderr; + + fprintf (stream, "# of ordinary maps: %d\n", LINEMAPS_ORDINARY_USED (set)); + fprintf (stream, "# of macro maps: %d\n", LINEMAPS_MACRO_USED (set)); + fprintf (stream, "Include stack depth: %d\n", set->depth); + fprintf (stream, "Highest location: %u\n", set->highest_location); + + if (num_ordinary) + { + fprintf (stream, "\nOrdinary line maps\n"); + for (i = 0; i < num_ordinary && i < LINEMAPS_ORDINARY_USED (set); i++) + linemap_dump (stream, set, i, false); + fprintf (stream, "\n"); + } + + if (num_macro) + { + fprintf (stream, "\nMacro line maps\n"); + for (i = 0; i < num_macro && i < LINEMAPS_MACRO_USED (set); i++) + linemap_dump (stream, set, i, true); + fprintf (stream, "\n"); + } +} + +/* class rich_location. */ + +/* Construct a rich_location with location LOC as its initial range. */ + +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_path (NULL), + m_escape_on_output (false) +{ + add_range (loc, SHOW_RANGE_WITH_CARET, label); +} + +/* The destructor for class rich_location. */ + +rich_location::~rich_location () +{ + for (unsigned int i = 0; i < m_fixit_hints.count (); i++) + delete get_fixit_hint (i); +} + +/* Get location IDX within this rich_location. */ + +location_t +rich_location::get_loc (unsigned int idx) const +{ + 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. */ +/* Get an expanded_location for this rich_location's primary + location. */ + +expanded_location +rich_location::get_expanded_location (unsigned int idx) +{ + if (idx == 0) + { + /* Cache the expansion of the primary location. */ + if (!m_have_expanded_location) + { + m_expanded_location + = linemap_client_expand_location_to_spelling_point + (get_loc (0), LOCATION_ASPECT_CARET); + if (m_column_override) + m_expanded_location.column = m_column_override; + m_have_expanded_location = true; + } + + return m_expanded_location; + } + else + return linemap_client_expand_location_to_spelling_point + (get_loc (idx), LOCATION_ASPECT_CARET); +} + +/* Set the column of the primary location, with 0 meaning + "don't override it". */ + +void +rich_location::override_column (int column) +{ + m_column_override = column; + m_have_expanded_location = false; +} + +/* Add the given range. */ + +void +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; + range.m_range_display_kind = range_display_kind; + range.m_label = label; + m_ranges.push (range); +} + +/* Add or overwrite the location given by IDX, setting its location to LOC, + and setting its m_range_display_kind to RANGE_DISPLAY_KIND. + + It must either overwrite an existing location, or add one *exactly* on + the end of the array. + + This is primarily for use by gcc when implementing diagnostic format + decoders e.g. + - the "+" in the C/C++ frontends, for handling format codes like "%q+D" + (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, 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 ()); + + if (idx == m_ranges.count ()) + add_range (loc, range_display_kind); + else + { + location_range *locrange = get_range (idx); + locrange->m_loc = loc; + locrange->m_range_display_kind = range_display_kind; + } + + 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 (location_t where, + const char *new_content) +{ + 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. */ + +void +rich_location::add_fixit_insert_after (const char *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 (location_t where, + const char *new_content) +{ + location_t finish = get_range_from_loc (m_line_table, where).m_finish; + 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) + { + stop_supporting_fixits (); + return; + } + + maybe_add_fixit (next_loc, 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 (location_t 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 + SRC_RANGE. */ + +void +rich_location::add_fixit_remove (source_range src_range) +{ + add_fixit_replace (src_range, ""); +} + +/* 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 (location_t 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 + SRC_RANGE with NEW_CONTENT. */ + +void +rich_location::add_fixit_replace (source_range src_range, + const char *new_content) +{ + location_t start = get_pure_location (m_line_table, src_range.m_start); + 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. */ + 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) + { + stop_supporting_fixits (); + return; + } + finish = next_loc; + + maybe_add_fixit (start, finish, 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 (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. */ + 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, + consolidating into the prior fixit if possible. */ + +void +rich_location::maybe_add_fixit (location_t start, + location_t next_loc, + const char *new_content) +{ + if (reject_impossible_fixit (start)) + return; + if (reject_impossible_fixit (next_loc)) + return; + + /* Only allow fix-it hints that affect a single line in one file. + Compare the end-points. */ + expanded_location exploc_start + = linemap_client_expand_location_to_spelling_point (start, + LOCATION_ASPECT_START); + expanded_location exploc_next_loc + = linemap_client_expand_location_to_spelling_point (next_loc, + LOCATION_ASPECT_START); + /* They must be within the same file... */ + if (exploc_start.file != exploc_next_loc.file) + { + stop_supporting_fixits (); + return; + } + /* ...and on the same line. */ + if (exploc_start.line != exploc_next_loc.line) + { + stop_supporting_fixits (); + return; + } + /* The columns must be in the correct order. This can fail if the + endpoints straddle the boundary for which the linemap can represent + columns (PR c/82050). */ + if (exploc_start.column > exploc_next_loc.column) + { + stop_supporting_fixits (); + return; + } + /* If we have very long lines, tokens will eventually fall back to + having column == 0. + We can't handle fix-it hints that use such locations. */ + if (exploc_start.column == 0 || exploc_next_loc.column == 0) + { + stop_supporting_fixits (); + return; + } + + const char *newline = strchr (new_content, '\n'); + if (newline) + { + /* For now, we can only support insertion of whole lines + i.e. starts at start of line, and the newline is at the end of + the insertion point. */ + + /* It must be an insertion, not a replacement/deletion. */ + if (start != next_loc) + { + stop_supporting_fixits (); + return; + } + + /* The insertion must be at the start of a line. */ + if (exploc_start.column != 1) + { + stop_supporting_fixits (); + return; + } + + /* The newline must be at end of NEW_CONTENT. + We could eventually split up fix-its at newlines if we wanted + to allow more generality (e.g. to allow adding multiple lines + with one add_fixit call. */ + if (newline[1] != '\0') + { + stop_supporting_fixits (); + return; + } + } + + /* Consolidate neighboring fixits. + Don't consolidate into newline-insertion fixits. */ + fixit_hint *prev = get_last_fixit_hint (); + if (prev && !prev->ends_with_newline_p ()) + if (prev->maybe_append (start, next_loc, new_content)) + return; + + m_fixit_hints.push (new fixit_hint (start, next_loc, new_content)); +} + +/* class fixit_hint. */ + +fixit_hint::fixit_hint (location_t start, + 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)) +{ +} + +/* Does this fix-it hint affect the given line? */ + +bool +fixit_hint::affects_line_p (const char *file, int line) const +{ + expanded_location exploc_start + = linemap_client_expand_location_to_spelling_point (m_start, + LOCATION_ASPECT_START); + if (file != exploc_start.file) + return false; + if (line < exploc_start.line) + return false; + expanded_location exploc_next_loc + = linemap_client_expand_location_to_spelling_point (m_next_loc, + LOCATION_ASPECT_START); + if (file != exploc_next_loc.file) + return false; + if (line > exploc_next_loc.line) + return false; + return true; +} + +/* Method for consolidating fix-it hints, for use by + rich_location::maybe_add_fixit. + 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 (location_t start, + 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) + return false; + + /* If so, we have neighboring replacements; merge them. */ + m_next_loc = next_loc; + 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; +} + +/* Return true iff this hint's content ends with a newline. */ + +bool +fixit_hint::ends_with_newline_p () const +{ + if (m_len == 0) + return false; + return m_bytes[m_len - 1] == '\n'; +} |