Retro68/gcc/libcpp/line-map.c

2485 lines
76 KiB
C
Raw Normal View History

2017-04-10 11:32:00 +00:00
/* Map (unsigned int) keys to (source file, line, column) triples.
Copyright (C) 2001-2017 Free Software Foundation, Inc.
2012-03-27 23:13:14 +00:00
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"
2014-09-21 17:33:12 +00:00
#include "hashtab.h"
2012-03-27 23:13:14 +00:00
2017-04-10 11:32:00 +00:00
/* Do not track column numbers higher than this one. As a result, the
range of column_bits is [12, 18] (or 0 if column numbers are
disabled). */
const unsigned int LINE_MAP_MAX_COLUMN_NUMBER = (1U << 12);
/* Highest possible source location encoded within an ordinary or
macro map. */
const source_location LINE_MAP_MAX_SOURCE_LOCATION = 0x70000000;
static void trace_include (const struct line_maps *, const line_map_ordinary *);
static const line_map_ordinary * linemap_ordinary_map_lookup (struct line_maps *,
source_location);
static const line_map_macro* linemap_macro_map_lookup (struct line_maps *,
source_location);
2012-03-27 23:13:14 +00:00
static source_location linemap_macro_map_loc_to_def_point
2017-04-10 11:32:00 +00:00
(const line_map_macro *, source_location);
2012-03-27 23:13:14 +00:00
static source_location linemap_macro_map_loc_to_exp_point
2017-04-10 11:32:00 +00:00
(const line_map_macro *, source_location);
2012-03-27 23:13:14 +00:00
static source_location linemap_macro_loc_to_spelling_point
2017-04-10 11:32:00 +00:00
(struct line_maps *, source_location, const line_map_ordinary **);
2012-03-27 23:13:14 +00:00
static source_location linemap_macro_loc_to_def_point (struct line_maps *,
source_location,
2017-04-10 11:32:00 +00:00
const line_map_ordinary **);
2012-03-27 23:13:14 +00:00
static source_location linemap_macro_loc_to_exp_point (struct line_maps *,
source_location,
2017-04-10 11:32:00 +00:00
const line_map_ordinary **);
2012-03-27 23:13:14 +00:00
/* 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 ()
{
htab_delete (location_adhoc_data_map.htab);
}
2014-09-21 17:33:12 +00:00
/* 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;
2017-04-10 11:32:00 +00:00
return ((hashval_t) lb->locus
+ (hashval_t) lb->src_range.m_start
+ (hashval_t) lb->src_range.m_finish
+ (size_t) lb->data);
2014-09-21 17:33:12 +00:00
}
/* 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;
2017-04-10 11:32:00 +00:00
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);
2014-09-21 17:33:12 +00:00
}
/* Update the hashtable when location_adhoc_data is reallocated. */
static int
location_adhoc_data_update (void **slot, void *data)
{
*((char **) slot) += *((int64_t *) data);
2014-09-21 17:33:12 +00:00
return 1;
}
/* Rebuild the hash table from the location adhoc data. */
void
rebuild_location_adhoc_htab (struct 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);
}
2017-04-10 11:32:00 +00:00
/* 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. */
static bool
can_be_stored_compactly_p (struct line_maps *set,
source_location 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. */
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. */
source_location 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;
}
2014-09-21 17:33:12 +00:00
/* Combine LOCUS and DATA to a combined adhoc loc. */
source_location
get_combined_adhoc_loc (struct line_maps *set,
2017-04-10 11:32:00 +00:00
source_location locus,
source_range src_range,
void *data)
2014-09-21 17:33:12 +00:00
{
struct location_adhoc_data lb;
struct location_adhoc_data **slot;
if (IS_ADHOC_LOC (locus))
locus
= set->location_adhoc_data_map.data[locus & MAX_SOURCE_LOCATION].locus;
if (locus == 0 && data == NULL)
return 0;
2017-04-10 11:32:00 +00:00
/* 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))
{
source_location 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++;
2014-09-21 17:33:12 +00:00
lb.locus = locus;
2017-04-10 11:32:00 +00:00
lb.src_range = src_range;
2014-09-21 17:33:12 +00:00
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;
int64_t offset;
2014-09-21 17:33:12 +00:00
/* 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 (struct line_maps *set, source_location loc)
{
linemap_assert (IS_ADHOC_LOC (loc));
return set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].data;
}
/* Return the location for the adhoc loc. */
source_location
get_location_from_adhoc_loc (struct line_maps *set, source_location loc)
{
linemap_assert (IS_ADHOC_LOC (loc));
return set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
}
2017-04-10 11:32:00 +00:00
/* Return the source_range for adhoc location LOC. */
static source_range
get_range_from_adhoc_loc (struct line_maps *set, source_location loc)
{
linemap_assert (IS_ADHOC_LOC (loc));
return set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].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,
source_location 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, source_location loc)
{
if (IS_ADHOC_LOC (loc))
return false;
const line_map *map = linemap_lookup (set, loc);
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. */
source_location
get_pure_location (line_maps *set, source_location loc)
2014-09-21 17:33:12 +00:00
{
if (IS_ADHOC_LOC (loc))
loc
= set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
if (loc >= LINEMAPS_MACRO_LOWEST_LOCATION (set))
return loc;
if (loc < RESERVED_LOCATION_COUNT)
return loc;
const line_map *map = linemap_lookup (set, loc);
const line_map_ordinary *ordmap = linemap_check_ordinary (map);
return loc & ~((1 << ordmap->m_range_bits) - 1);
2014-09-21 17:33:12 +00:00
}
2012-03-27 23:13:14 +00:00
/* Initialize a line map set. */
void
2015-08-28 15:33:40 +00:00
linemap_init (struct line_maps *set,
source_location builtin_location)
2012-03-27 23:13:14 +00:00
{
memset (set, 0, sizeof (struct line_maps));
set->highest_location = RESERVED_LOCATION_COUNT - 1;
set->highest_line = RESERVED_LOCATION_COUNT - 1;
2014-09-21 17:33:12 +00:00
set->location_adhoc_data_map.htab =
htab_create (100, location_adhoc_data_hash, location_adhoc_data_eq, NULL);
2015-08-28 15:33:40 +00:00
set->builtin_location = builtin_location;
2012-03-27 23:13:14 +00:00
}
/* Check for and warn about line_maps entered but not exited. */
void
linemap_check_files_exited (struct line_maps *set)
{
2017-04-10 11:32:00 +00:00
const line_map_ordinary *map;
2012-03-27 23:13:14 +00:00
/* Depending upon whether we are handling preprocessed input or
not, this can be a user error or an ICE. */
for (map = LINEMAPS_LAST_ORDINARY_MAP (set);
! MAIN_FILE_P (map);
map = INCLUDED_FROM (set, map))
fprintf (stderr, "line-map.c: file \"%s\" entered but not left\n",
ORDINARY_MAP_FILE_NAME (map));
}
/* 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 (struct line_maps *set,
enum lc_reason reason)
{
/* Depending on this variable, a macro map would be allocated in a
different memory location than an ordinary map. */
bool macro_map_p = (reason == LC_ENTER_MACRO);
struct line_map *result;
if (LINEMAPS_USED (set, macro_map_p) == LINEMAPS_ALLOCATED (set, macro_map_p))
{
/* We ran out of allocated line maps. Let's allocate more. */
2017-04-10 11:32:00 +00:00
size_t alloc_size;
2012-03-27 23:13:14 +00:00
2014-09-21 17:33:12 +00:00
/* Cast away extern "C" from the type of xrealloc. */
line_map_realloc reallocator = (set->reallocator
? set->reallocator
: (line_map_realloc) xrealloc);
2012-03-27 23:13:14 +00:00
line_map_round_alloc_size_func round_alloc_size =
set->round_alloc_size;
2017-04-10 11:32:00 +00:00
size_t map_size = (macro_map_p
? sizeof (line_map_macro)
: sizeof (line_map_ordinary));
2012-03-27 23:13:14 +00:00
/* We are going to execute some dance to try to reduce the
overhead of the memory allocator, in case we are using the
ggc-page.c one.
The actual size of memory we are going to get back from the
allocator is the smallest power of 2 that is greater than the
size we requested. So let's consider that size then. */
alloc_size =
(2 * LINEMAPS_ALLOCATED (set, macro_map_p) + 256)
2017-04-10 11:32:00 +00:00
* map_size;
2012-03-27 23:13:14 +00:00
/* Get the actual size of memory that is going to be allocated
by the allocator. */
alloc_size = round_alloc_size (alloc_size);
/* Now alloc_size contains the exact memory size we would get if
we have asked for the initial alloc_size amount of memory.
Let's get back to the number of macro map that amounts
to. */
LINEMAPS_ALLOCATED (set, macro_map_p) =
2017-04-10 11:32:00 +00:00
alloc_size / map_size;
2012-03-27 23:13:14 +00:00
/* And now let's really do the re-allocation. */
2017-04-10 11:32:00 +00:00
if (macro_map_p)
{
set->info_macro.maps
= (line_map_macro *) (*reallocator) (set->info_macro.maps,
(LINEMAPS_ALLOCATED (set, macro_map_p)
* map_size));
result = &set->info_macro.maps[LINEMAPS_USED (set, macro_map_p)];
}
else
{
set->info_ordinary.maps =
(line_map_ordinary *) (*reallocator) (set->info_ordinary.maps,
(LINEMAPS_ALLOCATED (set, macro_map_p)
* map_size));
result = &set->info_ordinary.maps[LINEMAPS_USED (set, macro_map_p)];
}
2012-03-27 23:13:14 +00:00
memset (result, 0,
((LINEMAPS_ALLOCATED (set, macro_map_p)
- LINEMAPS_USED (set, macro_map_p))
2017-04-10 11:32:00 +00:00
* map_size));
2012-03-27 23:13:14 +00:00
}
else
2017-04-10 11:32:00 +00:00
{
if (macro_map_p)
result = &set->info_macro.maps[LINEMAPS_USED (set, macro_map_p)];
else
result = &set->info_ordinary.maps[LINEMAPS_USED (set, macro_map_p)];
}
2012-03-27 23:13:14 +00:00
LINEMAPS_USED (set, macro_map_p)++;
result->reason = reason;
return result;
}
/* 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 (struct line_maps *set, enum lc_reason reason,
unsigned int sysp, const char *to_file, linenum_type to_line)
{
2017-04-10 11:32:00 +00:00
/* Generate a start_location above the current highest_location.
If possible, make the low range bits be zero. */
source_location 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);
linemap_assert (0 == (start_location
& ((1 << set->default_range_bits) - 1)));
}
else
start_location = set->highest_location + 1;
2012-03-27 23:13:14 +00:00
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;
}
2017-04-10 11:32:00 +00:00
linemap_assert (reason != LC_ENTER_MACRO);
line_map_ordinary *map = linemap_check_ordinary (new_linemap (set, reason));
2012-03-27 23:13:14 +00:00
if (to_file && *to_file == '\0' && reason != LC_RENAME_VERBATIM)
to_file = "<stdin>";
if (reason == LC_RENAME_VERBATIM)
reason = LC_RENAME;
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. */
2017-04-10 11:32:00 +00:00
line_map_ordinary *from;
2012-03-27 23:13:14 +00:00
2017-04-10 11:32:00 +00:00
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 = INCLUDED_FROM (set, map - 1);
2012-03-27 23:13:14 +00:00
/* A TO_FILE of NULL is special - we use the natural values. */
2017-04-10 11:32:00 +00:00
if (to_file == NULL)
2012-03-27 23:13:14 +00:00
{
to_file = ORDINARY_MAP_FILE_NAME (from);
to_line = SOURCE_LINE (from, from[1].start_location);
sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (from);
}
2017-04-10 11:32:00 +00:00
else
linemap_assert (filename_cmp (ORDINARY_MAP_FILE_NAME (from),
to_file) == 0);
2012-03-27 23:13:14 +00:00
}
2017-04-10 11:32:00 +00:00
map->sysp = sysp;
map->start_location = start_location;
map->to_file = to_file;
map->to_line = to_line;
2012-03-27 23:13:14 +00:00
LINEMAPS_ORDINARY_CACHE (set) = LINEMAPS_ORDINARY_USED (set) - 1;
2017-04-10 11:32:00 +00:00
map->m_column_and_range_bits = 0;
map->m_range_bits = 0;
2012-03-27 23:13:14 +00:00
set->highest_location = start_location;
set->highest_line = start_location;
set->max_column_hint = 0;
2017-04-10 11:32:00 +00:00
/* 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));
2012-03-27 23:13:14 +00:00
if (reason == LC_ENTER)
{
2017-04-10 11:32:00 +00:00
map->included_from =
2012-03-27 23:13:14 +00:00
set->depth == 0 ? -1 : (int) (LINEMAPS_ORDINARY_USED (set) - 2);
set->depth++;
if (set->trace_includes)
trace_include (set, map);
}
else if (reason == LC_RENAME)
2017-04-10 11:32:00 +00:00
map->included_from = ORDINARY_MAP_INCLUDER_FILE_INDEX (&map[-1]);
2012-03-27 23:13:14 +00:00
else if (reason == LC_LEAVE)
{
set->depth--;
2017-04-10 11:32:00 +00:00
map->included_from =
2012-03-27 23:13:14 +00:00
ORDINARY_MAP_INCLUDER_FILE_INDEX (INCLUDED_FROM (set, map - 1));
}
return map;
}
2014-09-21 17:33:12 +00:00
/* Returns TRUE if the line table set tracks token locations across
2012-03-27 23:13:14 +00:00
macro expansion, FALSE otherwise. */
bool
linemap_tracks_macro_expansion_locs_p (struct 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. */
2017-04-10 11:32:00 +00:00
const line_map_macro *
2012-03-27 23:13:14 +00:00
linemap_enter_macro (struct line_maps *set, struct cpp_hashnode *macro_node,
source_location expansion, unsigned int num_tokens)
{
2017-04-10 11:32:00 +00:00
line_map_macro *map;
2012-03-27 23:13:14 +00:00
source_location start_location;
2014-09-21 17:33:12 +00:00
/* Cast away extern "C" from the type of xrealloc. */
line_map_realloc reallocator = (set->reallocator
? set->reallocator
: (line_map_realloc) xrealloc);
2012-03-27 23:13:14 +00:00
start_location = LINEMAPS_MACRO_LOWEST_LOCATION (set) - num_tokens;
if (start_location <= set->highest_line
|| start_location > LINEMAPS_MACRO_LOWEST_LOCATION (set))
/* We ran out of macro map space. */
return NULL;
2017-04-10 11:32:00 +00:00
map = linemap_check_macro (new_linemap (set, LC_ENTER_MACRO));
2012-03-27 23:13:14 +00:00
2017-04-10 11:32:00 +00:00
map->start_location = start_location;
map->macro = macro_node;
map->n_tokens = num_tokens;
map->macro_locations
2012-03-27 23:13:14 +00:00
= (source_location*) reallocator (NULL,
2 * num_tokens
* sizeof (source_location));
2017-04-10 11:32:00 +00:00
map->expansion = expansion;
2012-03-27 23:13:14 +00:00
memset (MACRO_MAP_LOCATIONS (map), 0,
num_tokens * sizeof (source_location));
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).
2015-08-28 15:33:40 +00:00
ORIG_PARM_REPLACEMENT_LOC is the location in the macro definition,
2012-03-27 23:13:14 +00:00
either of the token itself or of a macro parameter that it
replaces. */
source_location
2017-04-10 11:32:00 +00:00
linemap_add_macro_token (const line_map_macro *map,
2012-03-27 23:13:14 +00:00
unsigned int token_no,
source_location orig_loc,
source_location orig_parm_replacement_loc)
{
source_location 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 source_location 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
linemap_line_start (struct line_maps *set, linenum_type to_line,
unsigned int max_column_hint)
{
2017-04-10 11:32:00 +00:00
line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set);
2012-03-27 23:13:14 +00:00
source_location highest = set->highest_location;
source_location r;
linenum_type last_line =
SOURCE_LINE (map, set->highest_line);
int line_delta = to_line - last_line;
bool add_map = false;
2017-04-10 11:32:00 +00:00
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;
2012-03-27 23:13:14 +00:00
if (line_delta < 0
|| (line_delta > 10
2017-04-10 11:32:00 +00:00
&& 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_SOURCE_LOCATION)))
2015-08-28 15:33:40 +00:00
add_map = true;
2012-03-27 23:13:14 +00:00
else
max_column_hint = set->max_column_hint;
if (add_map)
{
int column_bits;
2017-04-10 11:32:00 +00:00
int range_bits;
if (max_column_hint > LINE_MAP_MAX_COLUMN_NUMBER
|| highest > LINE_MAP_MAX_LOCATION_WITH_COLS)
2012-03-27 23:13:14 +00:00
{
/* If the column number is ridiculous or we've allocated a huge
2017-04-10 11:32:00 +00:00
number of source_locations, give up on column numbers
(and on packed ranges). */
2012-03-27 23:13:14 +00:00
max_column_hint = 0;
column_bits = 0;
2017-04-10 11:32:00 +00:00
range_bits = 0;
if (highest > LINE_MAP_MAX_SOURCE_LOCATION)
return 0;
2012-03-27 23:13:14 +00:00
}
else
{
column_bits = 7;
2017-04-10 11:32:00 +00:00
if (highest <= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES)
range_bits = set->default_range_bits;
else
range_bits = 0;
2012-03-27 23:13:14 +00:00
while (max_column_hint >= (1U << column_bits))
column_bits++;
max_column_hint = 1U << column_bits;
2017-04-10 11:32:00 +00:00
column_bits += range_bits;
2012-03-27 23:13:14 +00:00
}
/* 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))
2017-04-10 11:32:00 +00:00
|| 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;
2012-03-27 23:13:14 +00:00
r = (MAP_START_LOCATION (map)
+ ((to_line - ORDINARY_MAP_STARTING_LINE_NUMBER (map))
<< column_bits));
}
else
2017-04-10 11:32:00 +00:00
r = set->highest_line + (line_delta << map->m_column_and_range_bits);
2012-03-27 23:13:14 +00:00
/* Locations of ordinary tokens are always lower than locations of
macro tokens. */
if (r >= LINEMAPS_MACRO_LOWEST_LOCATION (set))
return 0;
set->highest_line = r;
if (r > set->highest_location)
set->highest_location = r;
set->max_column_hint = max_column_hint;
2017-04-10 11:32:00 +00:00
/* 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);
2012-03-27 23:13:14 +00:00
return r;
}
/* Encode and return a source_location 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
linemap_position_for_column (struct line_maps *set, unsigned int to_column)
{
source_location r = set->highest_line;
linemap_assert
(!linemap_macro_expansion_map_p (LINEMAPS_LAST_ORDINARY_MAP (set)));
if (to_column >= set->max_column_hint)
{
2017-04-10 11:32:00 +00:00
if (r > LINE_MAP_MAX_LOCATION_WITH_COLS
|| to_column > LINE_MAP_MAX_COLUMN_NUMBER)
2012-03-27 23:13:14 +00:00
{
/* Running low on source_locations - 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. */
2017-04-10 11:32:00 +00:00
line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set);
2012-03-27 23:13:14 +00:00
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;
}
2012-03-27 23:13:14 +00:00
}
}
2017-04-10 11:32:00 +00:00
line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set);
r = r + (to_column << map->m_range_bits);
2012-03-27 23:13:14 +00:00
if (r >= set->highest_location)
set->highest_location = r;
return r;
}
/* Encode and return a source location from a given line and
column. */
source_location
2017-04-10 11:32:00 +00:00
linemap_position_for_line_and_column (line_maps *set,
const line_map_ordinary *ord_map,
2012-03-27 23:13:14 +00:00
linenum_type line,
unsigned column)
{
2017-04-10 11:32:00 +00:00
linemap_assert (ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map) <= line);
source_location 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);
if (r >= upper_limit)
r = upper_limit - 1;
if (r > set->highest_location)
set->highest_location = r;
return r;
2012-03-27 23:13:14 +00:00
}
2015-08-28 15:33:40 +00:00
/* Encode and return a source_location starting from location LOC and
2017-04-10 11:32:00 +00:00
shifting it by COLUMN_OFFSET columns. This function does not support
2015-08-28 15:33:40 +00:00
virtual locations. */
source_location
linemap_position_for_loc_and_offset (struct line_maps *set,
source_location loc,
2017-04-10 11:32:00 +00:00
unsigned int column_offset)
2015-08-28 15:33:40 +00:00
{
2017-04-10 11:32:00 +00:00
const line_map_ordinary * map = NULL;
if (IS_ADHOC_LOC (loc))
loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
2015-08-28 15:33:40 +00:00
/* This function does not support virtual locations yet. */
if (linemap_assert_fails
(!linemap_location_from_macro_expansion_p (set, loc)))
return loc;
2017-04-10 11:32:00 +00:00
if (column_offset == 0
2015-08-28 15:33:40 +00:00
/* 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
2017-04-10 11:32:00 +00:00
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))
2015-08-28 15:33:40 +00:00
return loc;
2017-04-10 11:32:00 +00:00
linenum_type line = SOURCE_LINE (map, loc);
unsigned int column = SOURCE_COLUMN (map, loc);
2015-08-28 15:33:40 +00:00
/* 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
2017-04-10 11:32:00 +00:00
the next line map of the set. Otherwise, we try to encode the
location in the next map. */
while (map != LINEMAPS_LAST_ORDINARY_MAP (set)
&& (loc + (column_offset << map->m_range_bits)
>= MAP_START_LOCATION (&map[1])))
{
map = &map[1];
/* If the next map starts in a higher line, we cannot encode the
location there. */
if (line < ORDINARY_MAP_STARTING_LINE_NUMBER (map))
return loc;
}
2015-08-28 15:33:40 +00:00
2017-04-10 11:32:00 +00:00
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)))
2015-08-28 15:33:40 +00:00
return loc;
source_location r =
2017-04-10 11:32:00 +00:00
linemap_position_for_line_and_column (set, map, line, column);
2015-08-28 15:33:40 +00:00
if (linemap_assert_fails (r <= set->highest_location)
|| linemap_assert_fails (map == linemap_lookup (set, r)))
return loc;
return r;
}
2012-03-27 23:13:14 +00:00
/* 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)
{
2014-09-21 17:33:12 +00:00
if (IS_ADHOC_LOC (line))
line = set->location_adhoc_data_map.data[line & MAX_SOURCE_LOCATION].locus;
2012-03-27 23:13:14 +00:00
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. */
2017-04-10 11:32:00 +00:00
static const line_map_ordinary *
2012-03-27 23:13:14 +00:00
linemap_ordinary_map_lookup (struct line_maps *set, source_location line)
{
unsigned int md, mn, mx;
2017-04-10 11:32:00 +00:00
const line_map_ordinary *cached, *result;
2012-03-27 23:13:14 +00:00
2014-09-21 17:33:12 +00:00
if (IS_ADHOC_LOC (line))
line = set->location_adhoc_data_map.data[line & MAX_SOURCE_LOCATION].locus;
2012-03-27 23:13:14 +00:00
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]))
return cached;
}
else
{
mx = mn;
mn = 0;
}
while (mx - mn > 1)
{
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;
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. */
2017-04-10 11:32:00 +00:00
static const line_map_macro *
2012-03-27 23:13:14 +00:00
linemap_macro_map_lookup (struct line_maps *set, source_location line)
{
unsigned int md, mn, mx;
2017-04-10 11:32:00 +00:00
const struct line_map_macro *cached, *result;
2012-03-27 23:13:14 +00:00
2014-09-21 17:33:12 +00:00
if (IS_ADHOC_LOC (line))
line = set->location_adhoc_data_map.data[line & MAX_SOURCE_LOCATION].locus;
2012-03-27 23:13:14 +00:00
linemap_assert (line >= LINEMAPS_MACRO_LOWEST_LOCATION (set));
if (set == NULL)
return NULL;
mn = LINEMAPS_MACRO_CACHE (set);
mx = LINEMAPS_MACRO_USED (set);
cached = LINEMAPS_MACRO_MAP_AT (set, mn);
if (line >= MAP_START_LOCATION (cached))
{
if (mn == 0 || line < MAP_START_LOCATION (&cached[-1]))
return cached;
mx = mn - 1;
mn = 0;
}
while (mn < mx)
{
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;
result = LINEMAPS_MACRO_MAP_AT (set, LINEMAPS_MACRO_CACHE (set));
linemap_assert (MAP_START_LOCATION (result) <= line);
return result;
}
/* 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)
{
if (!map)
return false;
return (map->reason == LC_ENTER_MACRO);
}
/* 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 source_location
2017-04-10 11:32:00 +00:00
linemap_macro_map_loc_to_exp_point (const line_map_macro *map,
2012-03-27 23:13:14 +00:00
source_location 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);
}
2015-08-28 15:33:40 +00:00
/* LOCATION is the source location of a token that belongs to a macro
replacement-list as part of the macro expansion denoted by MAP.
2012-03-27 23:13:14 +00:00
2015-08-28 15:33:40 +00:00
Return the location of the token at the definition point of the
macro. */
static source_location
2017-04-10 11:32:00 +00:00
linemap_macro_map_loc_to_def_point (const line_map_macro *map,
2012-03-27 23:13:14 +00:00
source_location 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. */
source_location
2017-04-10 11:32:00 +00:00
linemap_macro_map_loc_unwind_toward_spelling (line_maps *set,
const line_map_macro* map,
2012-03-27 23:13:14 +00:00
source_location location)
{
unsigned token_no;
2017-04-10 11:32:00 +00:00
if (IS_ADHOC_LOC (location))
location = get_location_from_adhoc_loc (set, location);
2012-03-27 23:13:14 +00:00
linemap_assert (linemap_macro_expansion_map_p (map)
&& location >= MAP_START_LOCATION (map));
linemap_assert (location >= RESERVED_LOCATION_COUNT);
2017-04-10 11:32:00 +00:00
linemap_assert (!IS_ADHOC_LOC (location));
2012-03-27 23:13:14 +00:00
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 (struct line_maps *set,
source_location location)
{
2017-04-10 11:32:00 +00:00
const line_map_ordinary *map = NULL;
2012-03-27 23:13:14 +00:00
2014-09-21 17:33:12 +00:00
if (IS_ADHOC_LOC (location))
location = set->location_adhoc_data_map.data[location
& MAX_SOURCE_LOCATION].locus;
2012-03-27 23:13:14 +00:00
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 (struct line_maps *set,
source_location location)
{
2017-04-10 11:32:00 +00:00
const struct line_map_ordinary *map = NULL;
2012-03-27 23:13:14 +00:00
2014-09-21 17:33:12 +00:00
if (IS_ADHOC_LOC (location))
location = set->location_adhoc_data_map.data[location
& MAX_SOURCE_LOCATION].locus;
2012-03-27 23:13:14 +00:00
if (location < RESERVED_LOCATION_COUNT)
return NULL;
location =
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*
2017-04-10 11:32:00 +00:00
linemap_map_get_macro_name (const line_map_macro *macro_map)
2012-03-27 23:13:14 +00:00
{
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 (struct line_maps *set,
source_location location)
{
const struct line_map *map = NULL;
2014-09-21 17:33:12 +00:00
if (IS_ADHOC_LOC (location))
location = set->location_adhoc_data_map.data[location
& MAX_SOURCE_LOCATION].locus;
2012-03-27 23:13:14 +00:00
if (location < RESERVED_LOCATION_COUNT)
return false;
2014-09-21 17:33:12 +00:00
/* 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. */
2017-04-10 11:32:00 +00:00
return LINEMAP_SYSP (linemap_check_ordinary (map));
2014-09-21 17:33:12 +00:00
else
{
2017-04-10 11:32:00 +00:00
const line_map_macro *macro_map = linemap_check_macro (map);
2014-09-21 17:33:12 +00:00
/* It's a token resulting from a macro expansion. */
source_location loc =
2017-04-10 11:32:00 +00:00
linemap_macro_map_loc_unwind_toward_spelling (set, macro_map, location);
2014-09-21 17:33:12 +00:00
if (loc < RESERVED_LOCATION_COUNT)
/* This token might come from a built-in macro. Let's
look at where that macro got expanded. */
2017-04-10 11:32:00 +00:00
location = linemap_macro_map_loc_to_exp_point (macro_map, location);
2014-09-21 17:33:12 +00:00
else
location = loc;
}
}
else
break;
}
return false;
2012-03-27 23:13:14 +00:00
}
/* Return TRUE if LOCATION is a source code location of a token that is part of
a macro expansion, FALSE otherwise. */
2012-03-27 23:13:14 +00:00
bool
2015-08-28 15:33:40 +00:00
linemap_location_from_macro_expansion_p (const struct line_maps *set,
2012-03-27 23:13:14 +00:00
source_location location)
{
2014-09-21 17:33:12 +00:00
if (IS_ADHOC_LOC (location))
location = set->location_adhoc_data_map.data[location
& MAX_SOURCE_LOCATION].locus;
2012-03-27 23:13:14 +00:00
linemap_assert (location <= MAX_SOURCE_LOCATION
&& (set->highest_location
< LINEMAPS_MACRO_LOWEST_LOCATION (set)));
if (set == NULL)
return false;
return (location > set->highest_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,
source_location *loc0,
source_location *loc1)
{
source_location l0 = *loc0, l1 = *loc1;
const struct line_map *map0 = linemap_lookup (set, l0),
*map1 = linemap_lookup (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))
{
2017-04-10 11:32:00 +00:00
l0 = linemap_macro_map_loc_to_exp_point (linemap_check_macro (map0),
l0);
2012-03-27 23:13:14 +00:00
map0 = linemap_lookup (set, l0);
}
else
{
2017-04-10 11:32:00 +00:00
l1 = linemap_macro_map_loc_to_exp_point (linemap_check_macro (map1),
l1);
2012-03-27 23:13:14 +00:00
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. */
static const struct line_map*
first_map_in_common (struct line_maps *set,
source_location loc0,
source_location loc1,
source_location *res_loc0,
source_location *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 (struct line_maps *set,
source_location pre,
source_location post)
{
bool pre_virtual_p, post_virtual_p;
source_location l0 = pre, l1 = post;
2014-09-21 17:33:12 +00:00
if (IS_ADHOC_LOC (l0))
2017-04-10 11:32:00 +00:00
l0 = get_location_from_adhoc_loc (set, l0);
2014-09-21 17:33:12 +00:00
if (IS_ADHOC_LOC (l1))
2017-04-10 11:32:00 +00:00
l1 = get_location_from_adhoc_loc (set, l1);
2014-09-21 17:33:12 +00:00
2012-03-27 23:13:14 +00:00
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. */
unsigned i0, i1;
const struct line_map *map =
first_map_in_common (set, pre, post, &l0, &l1);
if (map == NULL)
/* This should not be possible. */
abort ();
i0 = l0 - MAP_START_LOCATION (map);
i1 = l1 - MAP_START_LOCATION (map);
return i1 - i0;
}
2017-04-10 11:32:00 +00:00
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);
2012-03-27 23:13:14 +00:00
return l1 - l0;
}
/* Print an include trace, for e.g. the -H option of the preprocessor. */
static void
2017-04-10 11:32:00 +00:00
trace_include (const struct line_maps *set, const line_map_ordinary *map)
2012-03-27 23:13:14 +00:00
{
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 source_location
linemap_macro_loc_to_spelling_point (struct line_maps *set,
source_location location,
2017-04-10 11:32:00 +00:00
const line_map_ordinary **original_map)
2012-03-27 23:13:14 +00:00
{
struct line_map *map;
linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
while (true)
{
2017-04-10 11:32:00 +00:00
map = const_cast <line_map *> (linemap_lookup (set, location));
2012-03-27 23:13:14 +00:00
if (!linemap_macro_expansion_map_p (map))
break;
2017-04-10 11:32:00 +00:00
location
= linemap_macro_map_loc_unwind_toward_spelling
(set, linemap_check_macro (map),
location);
2012-03-27 23:13:14 +00:00
}
if (original_map)
2017-04-10 11:32:00 +00:00
*original_map = linemap_check_ordinary (map);
2012-03-27 23:13:14 +00:00
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 source_location
linemap_macro_loc_to_def_point (struct line_maps *set,
source_location location,
2017-04-10 11:32:00 +00:00
const line_map_ordinary **original_map)
2012-03-27 23:13:14 +00:00
{
struct line_map *map;
2014-09-21 17:33:12 +00:00
if (IS_ADHOC_LOC (location))
location = set->location_adhoc_data_map.data[location
& MAX_SOURCE_LOCATION].locus;
2012-03-27 23:13:14 +00:00
linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
while (true)
{
2017-04-10 11:32:00 +00:00
map = const_cast <line_map *> (linemap_lookup (set, location));
2012-03-27 23:13:14 +00:00
if (!linemap_macro_expansion_map_p (map))
break;
location =
2017-04-10 11:32:00 +00:00
linemap_macro_map_loc_to_def_point (linemap_check_macro (map),
location);
2012-03-27 23:13:14 +00:00
}
if (original_map)
2017-04-10 11:32:00 +00:00
*original_map = linemap_check_ordinary (map);
2012-03-27 23:13:14 +00:00
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 source_location
linemap_macro_loc_to_exp_point (struct line_maps *set,
source_location location,
2017-04-10 11:32:00 +00:00
const line_map_ordinary **original_map)
2012-03-27 23:13:14 +00:00
{
struct line_map *map;
2014-09-21 17:33:12 +00:00
if (IS_ADHOC_LOC (location))
location = set->location_adhoc_data_map.data[location
& MAX_SOURCE_LOCATION].locus;
2012-03-27 23:13:14 +00:00
linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
while (true)
{
2017-04-10 11:32:00 +00:00
map = const_cast <line_map *> (linemap_lookup (set, location));
2012-03-27 23:13:14 +00:00
if (!linemap_macro_expansion_map_p (map))
break;
2017-04-10 11:32:00 +00:00
location = linemap_macro_map_loc_to_exp_point (linemap_check_macro (map),
location);
2012-03-27 23:13:14 +00:00
}
if (original_map)
2017-04-10 11:32:00 +00:00
*original_map = linemap_check_ordinary (map);
2012-03-27 23:13:14 +00:00
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
-------------------------------
2014-09-21 17:33:12 +00:00
The virtual location is resolved to the first macro expansion point
that led to this macro expansion.
2012-03-27 23:13:14 +00:00
* If LRK is set to LRK_SPELLING_LOCATION
-------------------------------------
2014-09-21 17:33:12 +00:00
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.
2012-03-27 23:13:14 +00:00
2014-09-21 17:33:12 +00:00
* If LRK is set to LRK_MACRO_DEFINITION_LOCATION
2012-03-27 23:13:14 +00:00
--------------------------------------
2014-09-21 17:33:12 +00:00
The virtual location is resolved to the locus of the token in the
context of the macro definition.
2012-03-27 23:13:14 +00:00
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.
2015-08-28 15:33:40 +00:00
If MAP is not NULL, *MAP is set to the map encoding the
2014-09-21 17:33:12 +00:00
returned location. Note that if the returned location wasn't originally
2015-08-28 15:33:40 +00:00
encoded by a map, then *MAP is set to NULL. This can happen if LOC
2012-03-27 23:13:14 +00:00
resolves to a location reserved for the client code, like
UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC. */
source_location
linemap_resolve_location (struct line_maps *set,
source_location loc,
enum location_resolution_kind lrk,
2017-04-10 11:32:00 +00:00
const line_map_ordinary **map)
2012-03-27 23:13:14 +00:00
{
2017-04-10 11:32:00 +00:00
source_location locus = loc;
2014-09-21 17:33:12 +00:00
if (IS_ADHOC_LOC (loc))
2017-04-10 11:32:00 +00:00
locus = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
2014-09-21 17:33:12 +00:00
2017-04-10 11:32:00 +00:00
if (locus < RESERVED_LOCATION_COUNT)
2012-03-27 23:13:14 +00:00
{
/* 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 (struct line_maps *set,
source_location loc)
{
if (IS_ADHOC_LOC (loc))
loc = get_location_from_adhoc_loc (set, loc);
if (!linemap_location_from_macro_expansion_p (set, loc))
return false;
while (true)
{
const struct line_map_macro *map
= linemap_check_macro (linemap_lookup (set, loc));
source_location s_loc
= linemap_macro_map_loc_unwind_toward_spelling (set, map, loc);
if (linemap_location_from_macro_expansion_p (set, s_loc))
loc = s_loc;
else
{
source_location def_loc
= linemap_macro_map_loc_to_def_point (map, loc);
return s_loc == def_loc;
}
}
}
2012-03-27 23:13:14 +00:00
/*
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. */
source_location
linemap_unwind_toward_expansion (struct line_maps *set,
source_location loc,
const struct line_map **map)
{
source_location resolved_location;
2017-04-10 11:32:00 +00:00
const line_map_macro *macro_map = linemap_check_macro (*map);
2012-03-27 23:13:14 +00:00
const struct line_map *resolved_map;
2014-09-21 17:33:12 +00:00
if (IS_ADHOC_LOC (loc))
loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
2012-03-27 23:13:14 +00:00
resolved_location =
2017-04-10 11:32:00 +00:00
linemap_macro_map_loc_unwind_toward_spelling (set, macro_map, loc);
2012-03-27 23:13:14 +00:00
resolved_map = linemap_lookup (set, resolved_location);
if (!linemap_macro_expansion_map_p (resolved_map))
{
2017-04-10 11:32:00 +00:00
resolved_location = linemap_macro_map_loc_to_exp_point (macro_map, loc);
2012-03-27 23:13:14 +00:00
resolved_map = linemap_lookup (set, resolved_location);
}
*map = resolved_map;
return resolved_location;
}
2014-09-21 17:33:12 +00:00
/* 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. */
source_location
linemap_unwind_to_first_non_reserved_loc (struct line_maps *set,
source_location loc,
const struct line_map **map)
{
source_location resolved_loc;
2017-04-10 11:32:00 +00:00
const struct line_map *map0 = NULL;
const line_map_ordinary *map1 = NULL;
2014-09-21 17:33:12 +00:00
if (IS_ADHOC_LOC (loc))
loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
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;
}
2012-03-27 23:13:14 +00:00
/* 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 (struct line_maps *set,
const struct line_map *map,
source_location loc)
{
expanded_location xloc;
memset (&xloc, 0, sizeof (xloc));
2014-09-21 17:33:12 +00:00
if (IS_ADHOC_LOC (loc))
{
xloc.data
= set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].data;
2017-04-10 11:32:00 +00:00
loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
2014-09-21 17:33:12 +00:00
}
2012-03-27 23:13:14 +00:00
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 ();
2017-04-10 11:32:00 +00:00
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;
2012-03-27 23:13:14 +00:00
}
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, struct line_maps *set, unsigned ix, bool is_macro)
{
const char *lc_reasons_v[LC_ENTER_MACRO + 1]
= { "LC_ENTER", "LC_LEAVE", "LC_RENAME", "LC_RENAME_VERBATIM",
"LC_ENTER_MACRO" };
const char *reason;
2017-04-10 11:32:00 +00:00
const line_map *map;
2012-03-27 23:13:14 +00:00
if (stream == NULL)
stream = stderr;
if (!is_macro)
map = LINEMAPS_ORDINARY_MAP_AT (set, ix);
else
map = LINEMAPS_MACRO_MAP_AT (set, ix);
reason = (map->reason <= LC_ENTER_MACRO) ? lc_reasons_v[map->reason] : "???";
fprintf (stream, "Map #%u [%p] - LOC: %u - REASON: %s - SYSP: %s\n",
ix, (void *) map, map->start_location, reason,
2017-04-10 11:32:00 +00:00
((!is_macro
&& ORDINARY_MAP_IN_SYSTEM_HEADER_P (linemap_check_ordinary (map)))
? "yes" : "no"));
2012-03-27 23:13:14 +00:00
if (!is_macro)
{
2017-04-10 11:32:00 +00:00
const line_map_ordinary *ord_map = linemap_check_ordinary (map);
2012-03-27 23:13:14 +00:00
unsigned includer_ix;
2017-04-10 11:32:00 +00:00
const line_map_ordinary *includer_map;
2012-03-27 23:13:14 +00:00
2017-04-10 11:32:00 +00:00
includer_ix = ORDINARY_MAP_INCLUDER_FILE_INDEX (ord_map);
2012-03-27 23:13:14 +00:00
includer_map = includer_ix < LINEMAPS_ORDINARY_USED (set)
? LINEMAPS_ORDINARY_MAP_AT (set, includer_ix)
: NULL;
2017-04-10 11:32:00 +00:00
fprintf (stream, "File: %s:%d\n", ORDINARY_MAP_FILE_NAME (ord_map),
ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map));
2012-03-27 23:13:14 +00:00
fprintf (stream, "Included from: [%d] %s\n", includer_ix,
includer_map ? ORDINARY_MAP_FILE_NAME (includer_map) : "None");
}
else
2017-04-10 11:32:00 +00:00
{
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));
}
2012-03-27 23:13:14 +00:00
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 (struct line_maps *set,
source_location loc,
FILE *stream)
{
2017-04-10 11:32:00 +00:00
const line_map_ordinary *map;
2012-03-27 23:13:14 +00:00
source_location location;
const char *path = "", *from = "";
int l = -1, c = -1, s = -1, e = -1;
2014-09-21 17:33:12 +00:00
if (IS_ADHOC_LOC (loc))
loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
2012-03-27 23:13:14 +00:00
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
from = (INCLUDED_FROM (set, map))
? LINEMAP_FILE (INCLUDED_FROM (set, 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);
}
2014-09-21 17:33:12 +00:00
/* 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 (struct line_maps *set,
const char *file_name,
source_location *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)
{
2017-04-10 11:32:00 +00:00
const char *fname = set->info_ordinary.maps[i].to_file;
2014-09-21 17:33:12 +00:00
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. */
source_location 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;
}
2012-03-27 23:13:14 +00:00
/* Compute and return statistics about the memory consumption of some
parts of the line table SET. */
void
linemap_get_statistics (struct 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;
2017-04-10 11:32:00 +00:00
const line_map_macro *cur_map;
2012-03-27 23:13:14 +00:00
ordinary_maps_allocated_size =
2017-04-10 11:32:00 +00:00
LINEMAPS_ORDINARY_ALLOCATED (set) * sizeof (struct line_map_ordinary);
2012-03-27 23:13:14 +00:00
ordinary_maps_used_size =
2017-04-10 11:32:00 +00:00
LINEMAPS_ORDINARY_USED (set) * sizeof (struct line_map_ordinary);
2012-03-27 23:13:14 +00:00
macro_maps_allocated_size =
2017-04-10 11:32:00 +00:00
LINEMAPS_MACRO_ALLOCATED (set) * sizeof (struct line_map_macro);
2012-03-27 23:13:14 +00:00
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 (source_location);
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);
}
}
macro_maps_used_size =
2017-04-10 11:32:00 +00:00
LINEMAPS_MACRO_USED (set) * sizeof (struct line_map_macro);
2012-03-27 23:13:14 +00:00
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;
2017-04-10 11:32:00 +00:00
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;
2012-03-27 23:13:14 +00:00
}
/* 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,
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");
}
}
2017-04-10 11:32:00 +00:00
/* struct source_range. */
/* Is there any part of this range on the given line? */
bool
source_range::intersects_line_p (const char *file, int line) const
{
expanded_location exploc_start
= linemap_client_expand_location_to_spelling_point (m_start);
if (file != exploc_start.file)
return false;
if (line < exploc_start.line)
return false;
expanded_location exploc_finish
= linemap_client_expand_location_to_spelling_point (m_finish);
if (file != exploc_finish.file)
return false;
if (line > exploc_finish.line)
return false;
return true;
}
/* class rich_location. */
/* Construct a rich_location with location LOC as its initial range. */
rich_location::rich_location (line_maps *set, source_location loc) :
m_line_table (set),
m_ranges (),
2017-04-10 11:32:00 +00:00
m_column_override (0),
m_have_expanded_location (false),
m_fixit_hints (),
m_seen_impossible_fixit (false)
2017-04-10 11:32:00 +00:00
{
add_range (loc, true);
}
/* 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);
2017-04-10 11:32:00 +00:00
}
/* Get location IDX within this rich_location. */
source_location
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];
2017-04-10 11:32:00 +00:00
}
/* 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));
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));
}
/* 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 (source_location loc, bool show_caret_p)
{
location_range range;
range.m_loc = loc;
range.m_show_caret_p = show_caret_p;
m_ranges.push (range);
2017-04-10 11:32:00 +00:00
}
/* Add or overwrite the location given by IDX, setting its location to LOC,
and setting its "should my caret be printed" flag to SHOW_CARET_P.
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 (line_maps * /*set*/, unsigned int idx,
source_location loc, bool show_caret_p)
{
/* We can either overwrite an existing range, or add one exactly
on the end of the array. */
linemap_assert (idx <= m_ranges.count ());
2017-04-10 11:32:00 +00:00
if (idx == m_ranges.count ())
add_range (loc, show_caret_p);
else
{
location_range *locrange = get_range (idx);
locrange->m_loc = loc;
locrange->m_show_caret_p = show_caret_p;
}
2017-04-10 11:32:00 +00:00
if (idx == 0)
/* Mark any cached value here as dirty. */
m_have_expanded_location = false;
}
/* Methods for adding insertion fix-it hints. */
/* Add a fixit-hint, suggesting insertion of NEW_CONTENT
immediately before the primary range's start location. */
void
rich_location::add_fixit_insert_before (const char *new_content)
{
add_fixit_insert_before (get_loc (), new_content);
}
/* Add a fixit-hint, suggesting insertion of NEW_CONTENT
immediately before the start of WHERE. */
void
rich_location::add_fixit_insert_before (source_location where,
const char *new_content)
{
source_location start = get_range_from_loc (m_line_table, where).m_start;
if (reject_impossible_fixit (start))
return;
/* We do not yet support newlines within fix-it hints. */
if (strchr (new_content, '\n'))
{
stop_supporting_fixits ();
return;
}
add_fixit (new fixit_insert (start, new_content));
}
2017-04-10 11:32:00 +00:00
/* Add a fixit-hint, suggesting insertion of NEW_CONTENT
immediately after the primary range's end-point. */
2017-04-10 11:32:00 +00:00
void
rich_location::add_fixit_insert_after (const char *new_content)
2017-04-10 11:32:00 +00:00
{
add_fixit_insert_after (get_loc (), new_content);
}
/* Add a fixit-hint, suggesting insertion of NEW_CONTENT
immediately after the end-point of WHERE. */
void
rich_location::add_fixit_insert_after (source_location where,
const char *new_content)
{
source_location finish = get_range_from_loc (m_line_table, where).m_finish;
if (reject_impossible_fixit (finish))
return;
source_location next_loc
= linemap_position_for_loc_and_offset (m_line_table, finish, 1);
/* linemap_position_for_loc_and_offset can fail, if so, it returns
its input value. */
if (next_loc == finish)
{
stop_supporting_fixits ();
return;
}
add_fixit (new fixit_insert (next_loc, new_content));
}
/* Methods for adding removal fix-it hints. */
/* Add a fixit-hint, suggesting removal of the content covered
by range 0. */
void
rich_location::add_fixit_remove ()
{
add_fixit_remove (get_loc ());
}
/* Add a fixit-hint, suggesting removal of the content between
the start and finish of WHERE. */
void
rich_location::add_fixit_remove (source_location where)
{
source_range range = get_range_from_loc (m_line_table, where);
add_fixit_remove (range);
2017-04-10 11:32:00 +00:00
}
/* 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, "");
}
/* Return true iff A is in the column directly before B, on the
same line of the same source file. */
static bool
column_before_p (line_maps *set, source_location a, source_location b)
{
if (IS_ADHOC_LOC (a))
a = get_location_from_adhoc_loc (set, a);
if (IS_ADHOC_LOC (b))
b = get_location_from_adhoc_loc (set, b);
/* They must both be in ordinary maps. */
const struct line_map *linemap_a = linemap_lookup (set, a);
if (linemap_macro_expansion_map_p (linemap_a))
return false;
const struct line_map *linemap_b = linemap_lookup (set, b);
if (linemap_macro_expansion_map_p (linemap_b))
return false;
/* To be on the same line, they must be in the same ordinary map. */
if (linemap_a != linemap_b)
return false;
linenum_type line_a
= SOURCE_LINE (linemap_check_ordinary (linemap_a), a);
linenum_type line_b
= SOURCE_LINE (linemap_check_ordinary (linemap_b), b);
if (line_a != line_b)
return false;
linenum_type column_a
= SOURCE_COLUMN (linemap_check_ordinary (linemap_a), a);
linenum_type column_b
= SOURCE_COLUMN (linemap_check_ordinary (linemap_b), b);
return column_b == column_a + 1;
}
/* Add a fixit-hint, suggesting replacement of the content covered
by range 0 with NEW_CONTENT. */
void
rich_location::add_fixit_replace (const char *new_content)
{
add_fixit_replace (get_loc (), new_content);
}
/* Methods for adding "replace" fix-it hints. */
/* Add a fixit-hint, suggesting replacement of the content between
the start and finish of WHERE with NEW_CONTENT. */
void
rich_location::add_fixit_replace (source_location where,
const char *new_content)
{
source_range range = get_range_from_loc (m_line_table, where);
add_fixit_replace (range, new_content);
2017-04-10 11:32:00 +00:00
}
/* 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)
{
src_range.m_start = get_pure_location (m_line_table, src_range.m_start);
src_range.m_finish = get_pure_location (m_line_table, src_range.m_finish);
if (reject_impossible_fixit (src_range.m_start))
return;
if (reject_impossible_fixit (src_range.m_finish))
return;
/* We do not yet support newlines within fix-it hints. */
if (strchr (new_content, '\n'))
{
stop_supporting_fixits ();
return;
}
/* Consolidate neighboring fixits. */
fixit_hint *prev = get_last_fixit_hint ();
if (prev)
if (prev->maybe_append_replace (m_line_table, src_range, new_content))
return;
add_fixit (new fixit_replace (src_range, new_content));
}
/* Get the last fix-it hint within this rich_location, or NULL if none. */
fixit_hint *
rich_location::get_last_fixit_hint () const
{
if (m_fixit_hints.count () > 0)
return get_fixit_hint (m_fixit_hints.count () - 1);
else
return NULL;
}
/* If WHERE is an "awkward" location, then mark this rich_location as not
supporting fixits, purging any thay were already added, and return true.
Otherwise (the common case), return false. */
bool
rich_location::reject_impossible_fixit (source_location where)
{
/* Fix-its within a rich_location should either all be suggested, or
none of them should be suggested.
Once we've rejected a fixit, we reject any more, even those
with reasonable locations. */
if (m_seen_impossible_fixit)
return true;
if (where <= LINE_MAP_MAX_LOCATION_WITH_COLS)
/* WHERE is a reasonable location for a fix-it; don't reject it. */
return false;
/* Otherwise we have an attempt to add a fix-it with an "awkward"
location: either one that we can't obtain column information
for (within an ordinary map), or one within a macro expansion. */
stop_supporting_fixits ();
return true;
}
/* Mark this rich_location as not supporting fixits, purging any that were
already added. */
void
rich_location::stop_supporting_fixits ()
{
m_seen_impossible_fixit = true;
/* Purge the rich_location of any fix-its that were already added. */
for (unsigned int i = 0; i < m_fixit_hints.count (); i++)
delete get_fixit_hint (i);
m_fixit_hints.truncate (0);
}
/* Add HINT to the fix-it hints in this rich_location. */
void
rich_location::add_fixit (fixit_hint *hint)
{
m_fixit_hints.push (hint);
2017-04-10 11:32:00 +00:00
}
/* class fixit_insert. */
fixit_insert::fixit_insert (source_location where,
const char *new_content)
: m_where (where),
m_bytes (xstrdup (new_content)),
m_len (strlen (new_content))
{
}
fixit_insert::~fixit_insert ()
{
free (m_bytes);
}
/* Implementation of fixit_hint::affects_line_p for fixit_insert. */
bool
fixit_insert::affects_line_p (const char *file, int line) const
2017-04-10 11:32:00 +00:00
{
expanded_location exploc
= linemap_client_expand_location_to_spelling_point (m_where);
if (file == exploc.file)
if (line == exploc.line)
return true;
return false;
}
/* Implementation of maybe_append_replace for fixit_insert. Reject
the attempt to consolidate fix-its. */
2017-04-10 11:32:00 +00:00
bool
fixit_insert::maybe_append_replace (line_maps *, source_range, const char *)
2017-04-10 11:32:00 +00:00
{
return false;
2017-04-10 11:32:00 +00:00
}
/* class fixit_replace. */
fixit_replace::fixit_replace (source_range src_range,
const char *new_content)
: m_src_range (src_range),
m_bytes (xstrdup (new_content)),
m_len (strlen (new_content))
{
}
fixit_replace::~fixit_replace ()
{
free (m_bytes);
}
/* Implementation of fixit_hint::affects_line_p for fixit_replace. */
bool
fixit_replace::affects_line_p (const char *file, int line) const
2017-04-10 11:32:00 +00:00
{
return m_src_range.intersects_line_p (file, line);
}
/* Implementation of maybe_append_replace for fixit_replace. If
possible, merge the new replacement into this one and return true.
Otherwise return false. */
bool
fixit_replace::maybe_append_replace (line_maps *set,
source_range src_range,
const char *new_content)
{
/* Does SRC_RANGE start immediately after this one finishes? */
if (!column_before_p (set, m_src_range.m_finish, src_range.m_start))
return false;
/* We have neighboring replacements; merge them. */
m_src_range.m_finish = src_range.m_finish;
size_t extra_len = strlen (new_content);
m_bytes = (char *)xrealloc (m_bytes, m_len + extra_len + 1);
memcpy (m_bytes + m_len, new_content, extra_len);
m_len += extra_len;
m_bytes[m_len] = '\0';
return true;
}